{"version":3,"file":"static/js/662.b540cfa1.js","mappings":"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","sources":["../node_modules/@microsoft/applicationinsights-web/node_modules/@microsoft/applicationinsights-common/dist-es5/Interfaces/Contracts/SeverityLevel.js","../node_modules/@microsoft/applicationinsights-web/node_modules/@microsoft/applicationinsights-core-js/dist-es5/JavaScriptSDK.Enums/EnumHelperFuncs.js","../node_modules/@microsoft/applicationinsights-web/node_modules/@microsoft/dynamicproto-js/src/DynamicProto.ts","../node_modules/@microsoft/applicationinsights-web/node_modules/@microsoft/applicationinsights-common/dist-es5/__DynamicConstants.js","../node_modules/@microsoft/applicationinsights-web/node_modules/@microsoft/applicationinsights-common/dist-es5/ConnectionStringParser.js","../node_modules/@microsoft/applicationinsights-web/node_modules/@microsoft/applicationinsights-common/dist-es5/Constants.js","../node_modules/@microsoft/applicationinsights-web/node_modules/@microsoft/applicationinsights-core-js/dist-es5/__DynamicConstants.js","../node_modules/@microsoft/applicationinsights-web/node_modules/@microsoft/applicationinsights-core-js/dist-es5/JavaScriptSDK/InternalConstants.js","../node_modules/@microsoft/applicationinsights-web/node_modules/@microsoft/applicationinsights-core-js/dist-es5/JavaScriptSDK/HelperFuncs.js","../node_modules/@microsoft/applicationinsights-web/node_modules/@microsoft/applicationinsights-shims/src/Constants.ts","../node_modules/@microsoft/applicationinsights-web/node_modules/@microsoft/applicationinsights-core-js/dist-es5/JavaScriptSDK/EnvUtils.js","../node_modules/@microsoft/applicationinsights-web/node_modules/@microsoft/applicationinsights-core-js/dist-es5/JavaScriptSDK/RandomHelper.js","../node_modules/@microsoft/applicationinsights-web/node_modules/@microsoft/applicationinsights-core-js/dist-es5/JavaScriptSDK/DataCacheHelper.js","../node_modules/@microsoft/applicationinsights-web/node_modules/@microsoft/applicationinsights-core-js/dist-es5/Config/ConfigDefaults.js","../node_modules/@microsoft/applicationinsights-web/node_modules/@microsoft/applicationinsights-core-js/dist-es5/Config/DynamicSupport.js","../node_modules/@microsoft/applicationinsights-web/node_modules/@microsoft/applicationinsights-core-js/dist-es5/Config/DynamicProperty.js","../node_modules/@microsoft/applicationinsights-web/node_modules/@microsoft/applicationinsights-core-js/dist-es5/JavaScriptSDK/AggregationError.js","../node_modules/@microsoft/applicationinsights-web/node_modules/@microsoft/applicationinsights-core-js/dist-es5/Config/DynamicState.js","../node_modules/@microsoft/applicationinsights-web/node_modules/@microsoft/applicationinsights-core-js/dist-es5/Config/DynamicConfig.js","../node_modules/@microsoft/applicationinsights-web/node_modules/@microsoft/applicationinsights-shims/src/TsLibShims.ts","../node_modules/@microsoft/applicationinsights-web/node_modules/@microsoft/applicationinsights-core-js/dist-es5/JavaScriptSDK/AsyncUtils.js","../node_modules/@microsoft/applicationinsights-web/node_modules/@microsoft/applicationinsights-core-js/dist-es5/JavaScriptSDK/Constants.js","../node_modules/@microsoft/applicationinsights-web/node_modules/@microsoft/applicationinsights-core-js/dist-es5/JavaScriptSDK/DbgExtensionUtils.js","../node_modules/@microsoft/applicationinsights-web/node_modules/@microsoft/applicationinsights-core-js/dist-es5/JavaScriptSDK/DiagnosticLogger.js","../node_modules/@microsoft/applicationinsights-web/node_modules/@microsoft/applicationinsights-core-js/dist-es5/JavaScriptSDK/CookieMgr.js","../node_modules/@microsoft/applicationinsights-web/node_modules/@microsoft/applicationinsights-core-js/dist-es5/Config/ConfigDefaultHelpers.js","../node_modules/@microsoft/applicationinsights-web/node_modules/@microsoft/applicationinsights-core-js/dist-es5/JavaScriptSDK/NotificationManager.js","../node_modules/@microsoft/applicationinsights-web/node_modules/@microsoft/applicationinsights-core-js/dist-es5/JavaScriptSDK/PerfManager.js","../node_modules/@microsoft/applicationinsights-web/node_modules/@microsoft/applicationinsights-core-js/dist-es5/JavaScriptSDK/W3cTraceParent.js","../node_modules/@microsoft/applicationinsights-web/node_modules/@microsoft/applicationinsights-core-js/dist-es5/JavaScriptSDK/TelemetryHelpers.js","../node_modules/@microsoft/applicationinsights-web/node_modules/@microsoft/applicationinsights-core-js/dist-es5/JavaScriptSDK/ProcessTelemetryContext.js","../node_modules/@microsoft/applicationinsights-web/node_modules/@microsoft/applicationinsights-core-js/dist-es5/JavaScriptSDK/BaseTelemetryPlugin.js","../node_modules/@microsoft/applicationinsights-web/node_modules/@microsoft/applicationinsights-core-js/dist-es5/JavaScriptSDK/UnloadHandlerContainer.js","../node_modules/@microsoft/applicationinsights-web/node_modules/@microsoft/applicationinsights-core-js/dist-es5/JavaScriptSDK/UnloadHookContainer.js","../node_modules/@microsoft/applicationinsights-web/node_modules/@microsoft/applicationinsights-core-js/dist-es5/JavaScriptSDK/TelemetryInitializerPlugin.js","../node_modules/@microsoft/applicationinsights-web/node_modules/@microsoft/applicationinsights-core-js/dist-es5/JavaScriptSDK/AppInsightsCore.js","../node_modules/@microsoft/applicationinsights-web/node_modules/@microsoft/applicationinsights-core-js/dist-es5/JavaScriptSDK/EventHelpers.js","../node_modules/@microsoft/applicationinsights-web/dist-es5/AISku.js","../node_modules/@microsoft/applicationinsights-web/dist-es5/InternalConstants.js","../node_modules/@microsoft/applicationinsights-web/dist-es5/__DynamicConstants.js","../node_modules/@microsoft/applicationinsights-web/node_modules/@microsoft/applicationinsights-common/dist-es5/applicationinsights-common.js"],"sourcesContent":["// Copyright (c) Microsoft Corporation. All rights reserved.\r\n// Licensed under the MIT License.\r\nimport { createEnumStyle } from \"@microsoft/applicationinsights-core-js\";\r\n/**\r\n * Defines the level of severity for the event.\r\n */\r\nexport var SeverityLevel = createEnumStyle({\r\n    Verbose: 0 /* eSeverityLevel.Verbose */,\r\n    Information: 1 /* eSeverityLevel.Information */,\r\n    Warning: 2 /* eSeverityLevel.Warning */,\r\n    Error: 3 /* eSeverityLevel.Error */,\r\n    Critical: 4 /* eSeverityLevel.Critical */\r\n});\r\n//# sourceMappingURL=SeverityLevel.js.map","// Copyright (c) Microsoft Corporation. All rights reserved.\r\n// Licensed under the MIT License.\r\nimport { createEnum, createTypeMap } from \"@nevware21/ts-utils\";\r\n/**\r\n * Create an enum style object which has both the key => value and value => key mappings\r\n * @param values - The values to populate on the new object\r\n * @returns\r\n */\r\nexport var createEnumStyle = createEnum;\r\n/**\r\n * Create a 2 index map that maps an enum's key and value to the defined map value, X[\"key\"] => mapValue and X[0] => mapValue.\r\n * Generic values\r\n * - E = the const enum type (typeof eRequestHeaders);\r\n * - V = Identifies the valid values for the keys, this should include both the enum numeric and string key of the type. The\r\n * resulting \"Value\" of each entry identifies the valid values withing the assignments.\r\n * @param values - The values to populate on the new object\r\n * @returns\r\n */\r\nexport var createValueMap = createTypeMap;\r\n//# sourceMappingURL=EnumHelperFuncs.js.map","// Copyright (c) Microsoft Corporation. All rights reserved.\r\n// Licensed under the MIT License.\r\n\r\nimport { getGlobal, objCreate, objHasOwnProperty, throwTypeError } from \"@nevware21/ts-utils\";\r\n\r\ninterface DynamicGlobalSettings {\r\n    /**\r\n     * Stores the global options which will also be exposed on the runtime global\r\n     */\r\n    o: IDynamicProtoOpts,\r\n\r\n    /**\r\n     * Internal Global used to generate a unique dynamic class name, every new class will increase this value\r\n     * @ignore\r\n     */ \r\n    n: number\r\n};\r\n\r\nconst UNDEFINED = \"undefined\";\r\n\r\n/**\r\n * Constant string defined to support minimization\r\n * @ignore\r\n */ \r\nconst Constructor = 'constructor';\r\n\r\n/**\r\n * Constant string defined to support minimization\r\n * @ignore\r\n */ \r\nconst Prototype = 'prototype';\r\n \r\n/**\r\n * Constant string defined to support minimization\r\n * @ignore\r\n */\r\nconst strFunction = 'function';\r\n\r\n/**\r\n * Used to define the name of the instance function lookup table\r\n * @ignore\r\n */ \r\nconst DynInstFuncTable = '_dynInstFuncs';\r\n \r\n/**\r\n * Name used to tag the dynamic prototype function\r\n * @ignore\r\n */ \r\nconst DynProxyTag = '_isDynProxy';\r\n \r\n/**\r\n * Name added to a prototype to define the dynamic prototype \"class\" name used to lookup the function table\r\n * @ignore\r\n */ \r\nconst DynClassName = '_dynClass';\r\n \r\n/**\r\n * Prefix added to the classname to avoid any name clashes with other instance level properties\r\n * @ignore\r\n */ \r\nconst DynClassNamePrefix = '_dynCls$';\r\n \r\n/**\r\n * A tag which is used to check if we have already to attempted to set the instance function if one is not present\r\n * @ignore\r\n */\r\nconst DynInstChkTag = '_dynInstChk';\r\n \r\n/**\r\n * A tag which is used to check if we are allows to try and set an instance function is one is not present. Using the same \r\n * tag name as the function level but a different const name for readability only.\r\n */\r\nconst DynAllowInstChkTag = DynInstChkTag;\r\n \r\n/**\r\n * The global (imported) instances where the global performance options are stored\r\n */\r\nconst DynProtoDefaultOptions = '_dfOpts';\r\n \r\n/**\r\n * Value used as the name of a class when it cannot be determined\r\n * @ignore\r\n */ \r\nconst UnknownValue = '_unknown_';\r\n \r\n/**\r\n * Constant string defined to support minimization\r\n * @ignore\r\n */\r\nconst str__Proto = \"__proto__\";\r\n \r\n/**\r\n * The polyfill version of __proto__ so that it doesn't cause issues for anyone not expecting it to exist\r\n */\r\nconst DynProtoBaseProto = \"_dyn\" + str__Proto;\r\n\r\n/**\r\n * Runtime Global holder for dynamicProto settings\r\n */\r\nconst DynProtoGlobalSettings = \"__dynProto$Gbl\";\r\n\r\n/**\r\n * Track the current prototype for IE8 as you can't look back to get the prototype\r\n */\r\nconst DynProtoCurrent = \"_dynInstProto\";\r\n  \r\n/**\r\n * Constant string defined to support minimization\r\n * @ignore\r\n */\r\nconst strUseBaseInst = 'useBaseInst';\r\n \r\n/**\r\n * Constant string defined to support minimization\r\n * @ignore\r\n */\r\nconst strSetInstFuncs = 'setInstFuncs';\r\n \r\nconst Obj = Object;\r\n\r\n/**\r\n * Pre-lookup to check if we are running on a modern browser (i.e. not IE8)\r\n * @ignore\r\n */\r\nlet _objGetPrototypeOf = Obj[\"getPrototypeOf\"];\r\n\r\n/**\r\n * Pre-lookup to check for the existence of this function\r\n */\r\nlet _objGetOwnProps = Obj[\"getOwnPropertyNames\"];\r\n\r\n// Since 1.1.7 moving these to the runtime global to work around mixed version and module issues\r\n// See Issue https://github.com/microsoft/DynamicProto-JS/issues/57 for details\r\nlet _gbl = getGlobal();\r\nlet _gblInst: DynamicGlobalSettings = _gbl[DynProtoGlobalSettings] || (_gbl[DynProtoGlobalSettings] = {\r\n    o: {\r\n        [strSetInstFuncs]: true,\r\n        [strUseBaseInst]: true\r\n    },\r\n    n: 1000                // Start new global index @ 1000 so we \"fix\" some cases when mixed with 1.1.6 or earlier\r\n});\r\n\r\n/**\r\n * Helper used to check whether the target is an Object prototype or Array prototype\r\n * @ignore\r\n */ \r\nfunction _isObjectOrArrayPrototype(target:any) {\r\n    return target && (target === Obj[Prototype] || target === Array[Prototype]);\r\n}\r\n\r\n/**\r\n * Helper used to check whether the target is an Object prototype, Array prototype or Function prototype\r\n * @ignore\r\n */ \r\nfunction _isObjectArrayOrFunctionPrototype(target:any) {\r\n    return _isObjectOrArrayPrototype(target) || target === Function[Prototype];\r\n}\r\n\r\n/**\r\n * Helper used to get the prototype of the target object as getPrototypeOf is not available in an ES3 environment.\r\n * @ignore\r\n */ \r\nfunction _getObjProto(target:any) {\r\n    let newProto;\r\n\r\n    if (target) {\r\n        // This method doesn't exist in older browsers (e.g. IE8)\r\n        if (_objGetPrototypeOf) {\r\n            return _objGetPrototypeOf(target);\r\n        }\r\n\r\n        let curProto = target[str__Proto] || target[Prototype] || (target[Constructor] ? target[Constructor][Prototype] : null);\r\n\r\n        // Using the pre-calculated value as IE8 doesn't support looking up the prototype of a prototype and thus fails for more than 1 base class\r\n        newProto = target[DynProtoBaseProto] || curProto;\r\n        if (!objHasOwnProperty(target, DynProtoBaseProto)) {\r\n            // As this prototype doesn't have this property then this is from an inherited class so newProto is the base to return so save it\r\n            // so we can look it up value (which for a multiple hierarchy dynamicProto will be the base class)\r\n            delete target[DynProtoCurrent];     // Delete any current value allocated to this instance so we pick up the value from prototype hierarchy\r\n            newProto = target[DynProtoBaseProto] = target[DynProtoCurrent] || target[DynProtoBaseProto];\r\n            target[DynProtoCurrent] = curProto;\r\n        }\r\n    }\r\n\r\n    return newProto;\r\n}\r\n\r\n/**\r\n * Helper to get the properties of an object, including none enumerable ones as functions on a prototype in ES6\r\n * are not enumerable.\r\n * @param target \r\n */\r\nfunction _forEachProp(target: any, func: (name: string) => void) {\r\n    let props: string[] = [];\r\n    if (_objGetOwnProps) {\r\n        props = _objGetOwnProps(target);\r\n    } else {\r\n        for (let name in target) {\r\n            if (typeof name === \"string\" && objHasOwnProperty(target, name)) {\r\n                props.push(name);\r\n            }\r\n        }\r\n    }\r\n\r\n    if (props && props.length > 0) {\r\n        for (let lp = 0; lp < props.length; lp++) {\r\n            func(props[lp]);\r\n        }\r\n    }\r\n}\r\n\r\n/**\r\n * Helper function to check whether the provided function name is a potential candidate for dynamic\r\n * callback and prototype generation.\r\n * @param target The target object, may be a prototype or class object\r\n * @param funcName The function name\r\n * @param skipOwn Skips the check for own property\r\n * @ignore\r\n */\r\nfunction _isDynamicCandidate(target:any, funcName:string, skipOwn:boolean) {\r\n    return (funcName !== Constructor && typeof target[funcName] === strFunction && (skipOwn || objHasOwnProperty(target, funcName)) && funcName !== str__Proto && funcName !== Prototype);\r\n}\r\n\r\n/**\r\n * Helper to throw a TypeError exception\r\n * @param message the message\r\n * @ignore\r\n */\r\nfunction _throwTypeError(message:string) {\r\n    throwTypeError(\"DynamicProto: \" + message);\r\n}\r\n\r\n/**\r\n * Returns a collection of the instance functions that are defined directly on the thisTarget object, it does \r\n * not return any inherited functions\r\n * @param thisTarget The object to get the instance functions from\r\n * @ignore\r\n */\r\nfunction _getInstanceFuncs(thisTarget:any): any {\r\n    // Get the base proto\r\n    var instFuncs = objCreate(null);\r\n\r\n    // Save any existing instance functions\r\n    _forEachProp(thisTarget, (name) => {\r\n        // Don't include any dynamic prototype instances - as we only want the real functions\r\n        if (!instFuncs[name] && _isDynamicCandidate(thisTarget, name, false)) {\r\n            // Create an instance callback for passing the base function to the caller\r\n            instFuncs[name] = thisTarget[name];\r\n        }\r\n    });\r\n\r\n    return instFuncs;\r\n}\r\n\r\n/**\r\n * Returns whether the value is included in the array\r\n * @param values The array of values\r\n * @param value  The value\r\n */\r\nfunction _hasVisited(values:any[], value:any) {\r\n    for (let lp = values.length - 1; lp >= 0; lp--) {\r\n        if (values[lp] === value) {\r\n            return true;\r\n        }\r\n    }\r\n\r\n    return false;\r\n}\r\n\r\n/**\r\n * Returns an object that contains callback functions for all \"base/super\" functions, this is used to \"save\"\r\n * enabling calling super.xxx() functions without requiring that the base \"class\" has defined a prototype references\r\n * @param target The current instance\r\n * @ignore\r\n */\r\nfunction _getBaseFuncs(classProto:any, thisTarget:any, instFuncs:any, useBaseInst:boolean): any {\r\n    function _instFuncProxy(target:any, funcHost: any,  funcName: string) {\r\n        let theFunc = funcHost[funcName];\r\n        if (theFunc[DynProxyTag] && useBaseInst) {\r\n            // grab and reuse the hosted looking function (if available) otherwise the original passed function\r\n            let instFuncTable = target[DynInstFuncTable] || {};\r\n            if (instFuncTable[DynAllowInstChkTag] !== false) {\r\n                theFunc = (instFuncTable[funcHost[DynClassName]] || {})[funcName] || theFunc;\r\n            }\r\n        }\r\n\r\n        return function() {\r\n            // eslint-disable-next-line prefer-rest-params\r\n            return theFunc.apply(target, arguments);\r\n        };\r\n    }\r\n\r\n    // Start creating a new baseFuncs by creating proxies for the instance functions (as they may get replaced)\r\n    var baseFuncs = objCreate(null);\r\n    _forEachProp(instFuncs, (name) => {\r\n        // Create an instance callback for passing the base function to the caller\r\n        baseFuncs[name] = _instFuncProxy(thisTarget, instFuncs, name);\r\n    });\r\n    \r\n    // Get the base prototype functions\r\n    var baseProto = _getObjProto(classProto);\r\n    let visited:any[] = [];\r\n\r\n    // Don't include base object functions for Object, Array or Function\r\n    while (baseProto && !_isObjectArrayOrFunctionPrototype(baseProto) && !_hasVisited(visited, baseProto)) {\r\n        // look for prototype functions\r\n        _forEachProp(baseProto, (name) => {\r\n            // Don't include any dynamic prototype instances - as we only want the real functions\r\n            // For IE 7/8 the prototype lookup doesn't provide the full chain so we need to bypass the \r\n            // hasOwnProperty check we get all of the methods, main difference is that IE7/8 doesn't return\r\n            // the Object prototype methods while bypassing the check\r\n            if (!baseFuncs[name] && _isDynamicCandidate(baseProto, name, !_objGetPrototypeOf)) {\r\n                // Create an instance callback for passing the base function to the caller\r\n                baseFuncs[name] = _instFuncProxy(thisTarget, baseProto, name);\r\n            }\r\n        });\r\n\r\n        // We need to find all possible functions that might be overloaded by walking the entire prototype chain\r\n        // This avoids the caller from needing to check whether it's direct base class implements the function or not\r\n        // by walking the entire chain it simplifies the usage and issues from upgrading any of the base classes.\r\n        visited.push(baseProto);\r\n        baseProto = _getObjProto(baseProto);\r\n    }\r\n\r\n    return baseFuncs;\r\n}\r\n\r\nfunction _getInstFunc(target: any, funcName: string, proto: any, currentDynProtoProxy: any) {\r\n    let instFunc = null;\r\n\r\n    // We need to check whether the class name is defined directly on this prototype otherwise\r\n    // it will walk the proto chain and return any parent proto classname.\r\n    if (target && objHasOwnProperty(proto, DynClassName)) {\r\n\r\n        let instFuncTable = target[DynInstFuncTable] || objCreate(null);\r\n        instFunc = (instFuncTable[proto[DynClassName]] || objCreate(null))[funcName];\r\n\r\n        if (!instFunc) {\r\n            // Avoid stack overflow from recursive calling the same function\r\n            _throwTypeError(\"Missing [\" + funcName + \"] \" + strFunction);\r\n        }\r\n\r\n        // We have the instance function, lets check it we can speed up further calls\r\n        // by adding the instance function back directly on the instance (avoiding the dynamic func lookup)\r\n        if (!instFunc[DynInstChkTag] && instFuncTable[DynAllowInstChkTag] !== false) {\r\n            // If the instance already has an instance function we can't replace it\r\n            let canAddInst = !objHasOwnProperty(target, funcName);\r\n\r\n            // Get current prototype\r\n            let objProto = _getObjProto(target);\r\n            let visited:any[] = [];\r\n\r\n            // Lookup the function starting at the top (instance level prototype) and traverse down, if the first matching function\r\n            // if nothing is found or if the first hit is a dynamic proto instance then we can safely add an instance shortcut\r\n            while (canAddInst && objProto && !_isObjectArrayOrFunctionPrototype(objProto) && !_hasVisited(visited, objProto)) {\r\n                let protoFunc = objProto[funcName];\r\n                if (protoFunc) {\r\n                    canAddInst = (protoFunc === currentDynProtoProxy);\r\n                    break;\r\n                }\r\n\r\n                // We need to find all possible initial functions to ensure that we don't bypass a valid override function\r\n                visited.push(objProto);\r\n                objProto = _getObjProto(objProto);\r\n            }\r\n\r\n            try {\r\n                if (canAddInst) {\r\n                    // This instance doesn't have an instance func and the class hierarchy does have a higher level prototype version\r\n                    // so it's safe to directly assign for any subsequent calls (for better performance)\r\n                    target[funcName] = instFunc;\r\n                }\r\n\r\n                // Block further attempts to set the instance function for any\r\n                instFunc[DynInstChkTag] = 1;\r\n            } catch (e) {\r\n                // Don't crash if the object is readonly or the runtime doesn't allow changing this\r\n                // And set a flag so we don't try again for any function\r\n                instFuncTable[DynAllowInstChkTag] = false;\r\n            }\r\n        }\r\n    }\r\n\r\n    return instFunc;\r\n}\r\n\r\nfunction _getProtoFunc(funcName: string, proto: any, currentDynProtoProxy: any) {\r\n    let protoFunc = proto[funcName];\r\n\r\n    // Check that the prototype function is not a self reference -- try to avoid stack overflow!\r\n    if (protoFunc === currentDynProtoProxy) {\r\n        // It is so lookup the base prototype\r\n        protoFunc = _getObjProto(proto)[funcName];\r\n    }\r\n\r\n    if (typeof protoFunc !== strFunction) {\r\n        _throwTypeError(\"[\" + funcName + \"] is not a \" + strFunction);\r\n    }\r\n\r\n    return protoFunc;\r\n}\r\n\r\n/**\r\n * Add the required dynamic prototype methods to the the class prototype\r\n * @param proto - The class prototype\r\n * @param className - The instance classname \r\n * @param target - The target instance\r\n * @param baseInstFuncs - The base instance functions\r\n * @param setInstanceFunc - Flag to allow prototype function to reset the instance function if one does not exist\r\n * @ignore\r\n */\r\nfunction _populatePrototype(proto:any, className:string, target:any, baseInstFuncs:any, setInstanceFunc:boolean) {\r\n    function _createDynamicPrototype(proto:any, funcName:string) {\r\n        let dynProtoProxy = function() {\r\n            // Use the instance or prototype function\r\n            let instFunc = _getInstFunc(this, funcName, proto, dynProtoProxy) || _getProtoFunc(funcName, proto, dynProtoProxy);\r\n            // eslint-disable-next-line prefer-rest-params\r\n            return instFunc.apply(this, arguments);\r\n        };\r\n        \r\n        // Tag this function as a proxy to support replacing dynamic proxy elements (primary use case is for unit testing\r\n        // via which can dynamically replace the prototype function reference)\r\n        (dynProtoProxy as any)[DynProxyTag] = 1;\r\n        return dynProtoProxy;\r\n    }\r\n    \r\n    if (!_isObjectOrArrayPrototype(proto)) {\r\n        let instFuncTable = target[DynInstFuncTable] = target[DynInstFuncTable] || objCreate(null);\r\n        if (!_isObjectOrArrayPrototype(instFuncTable)) {\r\n            let instFuncs = instFuncTable[className] = (instFuncTable[className] || objCreate(null)); // fetch and assign if as it may not exist yet\r\n\r\n            // Set whether we are allow to lookup instances, if someone has set to false then do not re-enable\r\n            if (instFuncTable[DynAllowInstChkTag] !== false) {\r\n                instFuncTable[DynAllowInstChkTag] = !!setInstanceFunc;\r\n            }\r\n\r\n            if (!_isObjectOrArrayPrototype(instFuncs)) {\r\n                _forEachProp(target, (name) => {\r\n                    // Only add overridden functions\r\n                    if (_isDynamicCandidate(target, name, false) && target[name] !== baseInstFuncs[name] ) {\r\n                        // Save the instance Function to the lookup table and remove it from the instance as it's not a dynamic proto function\r\n                        instFuncs[name] = target[name];\r\n                        delete target[name];\r\n                        \r\n                        // Add a dynamic proto if one doesn't exist or if a prototype function exists and it's not a dynamic one\r\n                        if (!objHasOwnProperty(proto, name) || (proto[name] && !proto[name][DynProxyTag])) {\r\n                            proto[name] = _createDynamicPrototype(proto, name);\r\n                        }\r\n                    }\r\n                });\r\n            }\r\n        }\r\n    }\r\n}\r\n\r\n/**\r\n * Checks whether the passed prototype object appears to be correct by walking the prototype hierarchy of the instance\r\n * @param classProto The class prototype instance\r\n * @param thisTarget The current instance that will be checked whether the passed prototype instance is in the hierarchy\r\n * @ignore\r\n */\r\nfunction _checkPrototype(classProto:any, thisTarget:any) {\r\n    // This method doesn't existing in older browsers (e.g. IE8)\r\n    if (_objGetPrototypeOf) {\r\n        // As this is primarily a coding time check, don't bother checking if running in IE8 or lower\r\n        let visited:any[] = [];\r\n        let thisProto = _getObjProto(thisTarget);\r\n        while (thisProto && !_isObjectArrayOrFunctionPrototype(thisProto) && !_hasVisited(visited, thisProto)) {\r\n            if (thisProto === classProto) {\r\n                return true;\r\n            }\r\n\r\n            // This avoids the caller from needing to check whether it's direct base class implements the function or not\r\n            // by walking the entire chain it simplifies the usage and issues from upgrading any of the base classes.\r\n            visited.push(thisProto);\r\n            thisProto = _getObjProto(thisProto);\r\n        }\r\n\r\n        return false;\r\n    }\r\n\r\n    // If objGetPrototypeOf doesn't exist then just assume everything is ok.\r\n    return true;\r\n}\r\n\r\n/**\r\n * Gets the current prototype name using the ES6 name if available otherwise falling back to a use unknown as the name.\r\n * It's not critical for this to return a name, it's used to decorate the generated unique name for easier debugging only.\r\n * @param target \r\n * @param unknownValue \r\n * @ignore\r\n */\r\nfunction _getObjName(target:any, unknownValue?:string) {\r\n    if (objHasOwnProperty(target, Prototype)) {\r\n        // Look like a prototype\r\n        return target.name || unknownValue || UnknownValue\r\n    }\r\n\r\n    return (((target || {})[Constructor]) || {}).name || unknownValue || UnknownValue;\r\n}\r\n\r\n/**\r\n * Interface to define additional configuration options to control how the dynamic prototype functions operate.\r\n */\r\nexport interface IDynamicProtoOpts {\r\n\r\n    /**\r\n     * Should the dynamic prototype attempt to set an instance function for instances that do not already have an\r\n     * function of the same name or have been extended by a class with a (non-dynamic proto) prototype function.\r\n     */\r\n    setInstFuncs: boolean,\r\n\r\n    /**\r\n     * When looking for base (super) functions if it finds a dynamic proto instances can it use the instance functions\r\n     * and bypass the prototype lookups. Defaults to true.\r\n     */\r\n    useBaseInst?: boolean\r\n}\r\n\r\n/**\r\n * The delegate signature for the function used as the callback for dynamicProto() \r\n * @typeparam DPType This is the generic type of the class, used to keep intellisense valid for the proxy instance, even \r\n * though it is only a proxy that only contains the functions \r\n * @param theTarget This is the real \"this\" of the current target object\r\n * @param baseFuncProxy The is a proxy object which ONLY contains this function that existed on the \"this\" instance before\r\n * calling dynamicProto, it does NOT contain properties of this. This is basically equivalent to using the \"super\" keyword.\r\n */\r\nexport type DynamicProtoDelegate<DPType> = (theTarget:DPType, baseFuncProxy?:DPType) => void;\r\n\r\n/**\r\n * Helper function when creating dynamic (inline) functions for classes, this helper performs the following tasks :-\r\n * - Saves references to all defined base class functions\r\n * - Calls the delegateFunc with the current target (this) and a base object reference that can be used to call all \"super\" functions.\r\n * - Will populate the class prototype for all overridden functions to support class extension that call the prototype instance.\r\n * Callers should use this helper when declaring all function within the constructor of a class, as mentioned above the delegateFunc is \r\n * passed both the target \"this\" and an object that can be used to call any base (super) functions, using this based object in place of\r\n * super.XXX() (which gets expanded to _super.prototype.XXX()) provides a better minification outcome and also ensures the correct \"this\"\r\n * context is maintained as TypeScript creates incorrect references using super.XXXX() for dynamically defined functions i.e. Functions\r\n * defined in the constructor or some other function (rather than declared as complete typescript functions).\r\n * ### Usage\r\n * ```typescript\r\n * import dynamicProto from \"@microsoft/dynamicproto-js\";\r\n * class ExampleClass extends BaseClass {\r\n *     constructor() {\r\n *         dynamicProto(ExampleClass, this, (_self, base) => {\r\n *             // This will define a function that will be converted to a prototype function\r\n *             _self.newFunc = () => {\r\n *                 // Access any \"this\" instance property  \r\n *                 if (_self.someProperty) {\r\n *                     ...\r\n *                 }\r\n *             }\r\n *             // This will define a function that will be converted to a prototype function\r\n *             _self.myFunction = () => {\r\n *                 // Access any \"this\" instance property\r\n *                 if (_self.someProperty) {\r\n *                     // Call the base version of the function that we are overriding\r\n *                     base.myFunction();\r\n *                 }\r\n *                 ...\r\n *             }\r\n *             _self.initialize = () => {\r\n *                 ...\r\n *             }\r\n *             // Warnings: While the following will work as _self is simply a reference to\r\n *             // this, if anyone overrides myFunction() the overridden will be called first\r\n *             // as the normal JavaScript method resolution will occur and the defined\r\n *             // _self.initialize() function is actually gets removed from the instance and\r\n *             // a proxy prototype version is created to reference the created method.\r\n *             _self.initialize();\r\n *         });\r\n *     }\r\n * }\r\n * ```\r\n * @typeparam DPType This is the generic type of the class, used to keep intellisense valid\r\n * @typeparam DPCls The type that contains the prototype of the current class\r\n * @param theClass - This is the current class instance which contains the prototype for the current class\r\n * @param target - The current \"this\" (target) reference, when the class has been extended this.prototype will not be the 'theClass' value.\r\n * @param delegateFunc - The callback function (closure) that will create the dynamic function\r\n * @param options - Additional options to configure how the dynamic prototype operates\r\n */\r\nexport default function dynamicProto<DPType, DPCls>(theClass:DPCls, target:DPType, delegateFunc: DynamicProtoDelegate<DPType>, options?:IDynamicProtoOpts): void {\r\n    // Make sure that the passed theClass argument looks correct\r\n    if (!objHasOwnProperty(theClass, Prototype)) {\r\n        _throwTypeError(\"theClass is an invalid class definition.\");\r\n    }\r\n\r\n    // Quick check to make sure that the passed theClass argument looks correct (this is a common copy/paste error)\r\n    let classProto = theClass[Prototype];\r\n    if (!_checkPrototype(classProto, target)) {\r\n        _throwTypeError(\"[\" + _getObjName(theClass) + \"] not in hierarchy of [\" + _getObjName(target) + \"]\");\r\n    }\r\n\r\n    let className = null;\r\n    if (objHasOwnProperty(classProto, DynClassName)) {\r\n        // Only grab the class name if it's defined on this prototype (i.e. don't walk the prototype chain)\r\n        className = classProto[DynClassName];\r\n    } else {\r\n        // As not all browser support name on the prototype creating a unique dynamic one if we have not already\r\n        // assigned one, so we can use a simple string as the lookup rather than an object for the dynamic instance\r\n        // function table lookup.\r\n        className = DynClassNamePrefix + _getObjName(theClass, \"_\") + \"$\" + _gblInst.n ;\r\n        _gblInst.n++;\r\n        classProto[DynClassName] = className;\r\n    }\r\n\r\n    let perfOptions = dynamicProto[DynProtoDefaultOptions];\r\n    let useBaseInst = !!perfOptions[strUseBaseInst];\r\n    if (useBaseInst && options && options[strUseBaseInst] !== undefined) {\r\n        useBaseInst = !!options[strUseBaseInst];\r\n    }\r\n\r\n    // Get the current instance functions\r\n    let instFuncs = _getInstanceFuncs(target);\r\n\r\n    // Get all of the functions for any base instance (before they are potentially overridden)\r\n    let baseFuncs = _getBaseFuncs(classProto, target, instFuncs, useBaseInst);\r\n\r\n    // Execute the delegate passing in both the current target \"this\" and \"base\" function references\r\n    // Note casting the same type as we don't actually have the base class here and this will provide some intellisense support\r\n    delegateFunc(target, baseFuncs as DPType);\r\n\r\n    // Don't allow setting instance functions for older IE instances\r\n    let setInstanceFunc = !!_objGetPrototypeOf && !!perfOptions[strSetInstFuncs];\r\n    if (setInstanceFunc && options) {\r\n        setInstanceFunc = !!options[strSetInstFuncs];\r\n    }\r\n\r\n    // Populate the Prototype for any overridden instance functions\r\n    _populatePrototype(classProto, className, target, instFuncs, setInstanceFunc !== false);\r\n}\r\n\r\n/**\r\n * Exposes the default global options to allow global configuration, if the global values are disabled these will override\r\n * any passed values. This is primarily exposed to support unit-testing without the need for individual classes to expose\r\n * their internal usage of dynamic proto.\r\n */\r\ndynamicProto[DynProtoDefaultOptions] = _gblInst.o;\r\n","// Copyright (c) Microsoft Corporation. All rights reserved.\r\n// Licensed under the MIT License.\r\n// @skip-file-minify\r\n// ##############################################################\r\n// AUTO GENERATED FILE: This file is Auto Generated during build.\r\n// ##############################################################\r\n// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\r\n// Note: DON'T Export these const from the package as we are still targeting ES3 this will export a mutable variables that someone could change!!!\r\n// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\r\nexport var _DYN_SPLIT = \"split\"; // Count: 6\r\nexport var _DYN_LENGTH = \"length\"; // Count: 41\r\nexport var _DYN_TO_LOWER_CASE = \"toLowerCase\"; // Count: 6\r\nexport var _DYN_INGESTIONENDPOINT = \"ingestionendpoint\"; // Count: 4\r\nexport var _DYN_TO_STRING = \"toString\"; // Count: 9\r\nexport var _DYN_REMOVE_ITEM = \"removeItem\"; // Count: 3\r\nexport var _DYN_NAME = \"name\"; // Count: 11\r\nexport var _DYN_MESSAGE = \"message\"; // Count: 10\r\nexport var _DYN_COUNT = \"count\"; // Count: 8\r\nexport var _DYN_PRE_TRIGGER_DATE = \"preTriggerDate\"; // Count: 4\r\nexport var _DYN_DISABLED = \"disabled\"; // Count: 3\r\nexport var _DYN_INTERVAL = \"interval\"; // Count: 3\r\nexport var _DYN_DAYS_OF_MONTH = \"daysOfMonth\"; // Count: 3\r\nexport var _DYN_DATE = \"date\"; // Count: 5\r\nexport var _DYN_GET_UTCDATE = \"getUTCDate\"; // Count: 3\r\nexport var _DYN_STRINGIFY = \"stringify\"; // Count: 4\r\nexport var _DYN_PATHNAME = \"pathname\"; // Count: 4\r\nexport var _DYN_CORRELATION_HEADER_E0 = \"correlationHeaderExcludePatterns\"; // Count: 2\r\nexport var _DYN_EXTENSION_CONFIG = \"extensionConfig\"; // Count: 4\r\nexport var _DYN_EXCEPTIONS = \"exceptions\"; // Count: 6\r\nexport var _DYN_PARSED_STACK = \"parsedStack\"; // Count: 13\r\nexport var _DYN_PROPERTIES = \"properties\"; // Count: 9\r\nexport var _DYN_MEASUREMENTS = \"measurements\"; // Count: 9\r\nexport var _DYN_SIZE_IN_BYTES = \"sizeInBytes\"; // Count: 11\r\nexport var _DYN_TYPE_NAME = \"typeName\"; // Count: 11\r\nexport var _DYN_SEVERITY_LEVEL = \"severityLevel\"; // Count: 5\r\nexport var _DYN_PROBLEM_GROUP = \"problemGroup\"; // Count: 3\r\nexport var _DYN_IS_MANUAL = \"isManual\"; // Count: 3\r\nexport var _DYN__CREATE_FROM_INTERFA1 = \"CreateFromInterface\"; // Count: 2\r\nexport var _DYN_ASSEMBLY = \"assembly\"; // Count: 7\r\nexport var _DYN_HAS_FULL_STACK = \"hasFullStack\"; // Count: 6\r\nexport var _DYN_LEVEL = \"level\"; // Count: 5\r\nexport var _DYN_METHOD = \"method\"; // Count: 7\r\nexport var _DYN_FILE_NAME = \"fileName\"; // Count: 6\r\nexport var _DYN_LINE = \"line\"; // Count: 6\r\nexport var _DYN_DURATION = \"duration\"; // Count: 4\r\nexport var _DYN_RECEIVED_RESPONSE = \"receivedResponse\"; // Count: 2\r\n//# sourceMappingURL=__DynamicConstants.js.map","// Copyright (c) Microsoft Corporation. All rights reserved.\r\n// Licensed under the MIT License.\r\nimport { arrReduce, objKeys } from \"@microsoft/applicationinsights-core-js\";\r\nimport { DEFAULT_BREEZE_ENDPOINT } from \"./Constants\";\r\nimport { _DYN_INGESTIONENDPOINT, _DYN_LENGTH, _DYN_SPLIT, _DYN_TO_LOWER_CASE } from \"./__DynamicConstants\";\r\nvar _FIELDS_SEPARATOR = \";\";\r\nvar _FIELD_KEY_VALUE_SEPARATOR = \"=\";\r\nexport function parseConnectionString(connectionString) {\r\n    if (!connectionString) {\r\n        return {};\r\n    }\r\n    var kvPairs = connectionString[_DYN_SPLIT /* @min:%2esplit */](_FIELDS_SEPARATOR);\r\n    var result = arrReduce(kvPairs, function (fields, kv) {\r\n        var kvParts = kv[_DYN_SPLIT /* @min:%2esplit */](_FIELD_KEY_VALUE_SEPARATOR);\r\n        if (kvParts[_DYN_LENGTH /* @min:%2elength */] === 2) { // only save fields with valid formats\r\n            var key = kvParts[0][_DYN_TO_LOWER_CASE /* @min:%2etoLowerCase */]();\r\n            var value = kvParts[1];\r\n            fields[key] = value;\r\n        }\r\n        return fields;\r\n    }, {});\r\n    if (objKeys(result)[_DYN_LENGTH /* @min:%2elength */] > 0) {\r\n        // this is a valid connection string, so parse the results\r\n        if (result.endpointsuffix) {\r\n            // use endpoint suffix where overrides are not provided\r\n            var locationPrefix = result.location ? result.location + \".\" : \"\";\r\n            result[_DYN_INGESTIONENDPOINT /* @min:%2eingestionendpoint */] = result[_DYN_INGESTIONENDPOINT /* @min:%2eingestionendpoint */] || (\"https://\" + locationPrefix + \"dc.\" + result.endpointsuffix);\r\n        }\r\n        // apply the default endpoints\r\n        result[_DYN_INGESTIONENDPOINT /* @min:%2eingestionendpoint */] = result[_DYN_INGESTIONENDPOINT /* @min:%2eingestionendpoint */] || DEFAULT_BREEZE_ENDPOINT;\r\n    }\r\n    return result;\r\n}\r\nexport var ConnectionStringParser = {\r\n    parse: parseConnectionString\r\n};\r\n//# sourceMappingURL=ConnectionStringParser.js.map","// Copyright (c) Microsoft Corporation. All rights reserved.\r\n// Licensed under the MIT License.\r\n/**\r\n * This is an internal property used to cause internal (reporting) requests to be ignored from reporting\r\n * additional telemetry, to handle polyfil implementations ALL urls used with a disabled request will\r\n * also be ignored for future requests even when this property is not provided.\r\n * Tagging as Ignore as this is an internal value and is not expected to be used outside of the SDK\r\n * @ignore\r\n */\r\nexport var DisabledPropertyName = \"Microsoft_ApplicationInsights_BypassAjaxInstrumentation\";\r\nexport var SampleRate = \"sampleRate\";\r\nexport var ProcessLegacy = \"ProcessLegacy\";\r\nexport var HttpMethod = \"http.method\";\r\nexport var DEFAULT_BREEZE_ENDPOINT = \"https://dc.services.visualstudio.com\";\r\nexport var DEFAULT_BREEZE_PATH = \"/v2/track\";\r\nexport var strNotSpecified = \"not_specified\";\r\nexport var strIkey = \"iKey\";\r\n//# sourceMappingURL=Constants.js.map","// Copyright (c) Microsoft Corporation. All rights reserved.\r\n// Licensed under the MIT License.\r\n// @skip-file-minify\r\n// ##############################################################\r\n// AUTO GENERATED FILE: This file is Auto Generated during build.\r\n// ##############################################################\r\n// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\r\n// Note: DON'T Export these const from the package as we are still targeting ES3 this will export a mutable variables that someone could change!!!\r\n// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\r\nexport var _DYN_TO_LOWER_CASE = \"toLowerCase\"; // Count: 9\r\nexport var _DYN_BLK_VAL = \"blkVal\"; // Count: 5\r\nexport var _DYN_LENGTH = \"length\"; // Count: 42\r\nexport var _DYN_RD_ONLY = \"rdOnly\"; // Count: 4\r\nexport var _DYN_NOTIFY = \"notify\"; // Count: 4\r\nexport var _DYN_WARN_TO_CONSOLE = \"warnToConsole\"; // Count: 4\r\nexport var _DYN_THROW_INTERNAL = \"throwInternal\"; // Count: 5\r\nexport var _DYN_SET_DF = \"setDf\"; // Count: 6\r\nexport var _DYN_WATCH = \"watch\"; // Count: 9\r\nexport var _DYN_LOGGER = \"logger\"; // Count: 21\r\nexport var _DYN_APPLY = \"apply\"; // Count: 7\r\nexport var _DYN_PUSH = \"push\"; // Count: 31\r\nexport var _DYN_SPLICE = \"splice\"; // Count: 8\r\nexport var _DYN_HDLR = \"hdlr\"; // Count: 6\r\nexport var _DYN_CANCEL = \"cancel\"; // Count: 5\r\nexport var _DYN_INITIALIZE = \"initialize\"; // Count: 4\r\nexport var _DYN_IDENTIFIER = \"identifier\"; // Count: 8\r\nexport var _DYN_IS_INITIALIZED = \"isInitialized\"; // Count: 10\r\nexport var _DYN_GET_PLUGIN = \"getPlugin\"; // Count: 6\r\nexport var _DYN_POLL_INTERNAL_LOGS = \"pollInternalLogs\"; // Count: 2\r\nexport var _DYN_NAME = \"name\"; // Count: 11\r\nexport var _DYN_TIME = \"time\"; // Count: 6\r\nexport var _DYN_PROCESS_NEXT = \"processNext\"; // Count: 15\r\nexport var _DYN_GET_PROCESS_TEL_CONT0 = \"getProcessTelContext\"; // Count: 2\r\nexport var _DYN_GET_NOTIFY_MGR = \"getNotifyMgr\"; // Count: 5\r\nexport var _DYN_ADD_NOTIFICATION_LIS1 = \"addNotificationListener\"; // Count: 4\r\nexport var _DYN_REMOVE_NOTIFICATION_2 = \"removeNotificationListener\"; // Count: 4\r\nexport var _DYN_ENABLED = \"enabled\"; // Count: 6\r\nexport var _DYN_STOP_POLLING_INTERNA3 = \"stopPollingInternalLogs\"; // Count: 2\r\nexport var _DYN_UNLOAD = \"unload\"; // Count: 9\r\nexport var _DYN_ON_COMPLETE = \"onComplete\"; // Count: 5\r\nexport var _DYN_VERSION = \"version\"; // Count: 6\r\nexport var _DYN_LOGGING_LEVEL_CONSOL4 = \"loggingLevelConsole\"; // Count: 2\r\nexport var _DYN_CREATE_NEW = \"createNew\"; // Count: 7\r\nexport var _DYN_TEARDOWN = \"teardown\"; // Count: 9\r\nexport var _DYN_MESSAGE_ID = \"messageId\"; // Count: 4\r\nexport var _DYN_MESSAGE = \"message\"; // Count: 6\r\nexport var _DYN_IS_ASYNC = \"isAsync\"; // Count: 6\r\nexport var _DYN_DIAG_LOG = \"diagLog\"; // Count: 10\r\nexport var _DYN__DO_TEARDOWN = \"_doTeardown\"; // Count: 4\r\nexport var _DYN_UPDATE = \"update\"; // Count: 6\r\nexport var _DYN_GET_NEXT = \"getNext\"; // Count: 12\r\nexport var _DYN_SET_NEXT_PLUGIN = \"setNextPlugin\"; // Count: 5\r\nexport var _DYN_USER_AGENT = \"userAgent\"; // Count: 5\r\nexport var _DYN_SPLIT = \"split\"; // Count: 5\r\nexport var _DYN_NODE_TYPE = \"nodeType\"; // Count: 3\r\nexport var _DYN_REPLACE = \"replace\"; // Count: 8\r\nexport var _DYN_LOG_INTERNAL_MESSAGE = \"logInternalMessage\"; // Count: 2\r\nexport var _DYN_TYPE = \"type\"; // Count: 14\r\nexport var _DYN_HANDLER = \"handler\"; // Count: 5\r\nexport var _DYN_IS_CHILD_EVT = \"isChildEvt\"; // Count: 3\r\nexport var _DYN_GET_CTX = \"getCtx\"; // Count: 6\r\nexport var _DYN_SET_CTX = \"setCtx\"; // Count: 10\r\nexport var _DYN_COMPLETE = \"complete\"; // Count: 3\r\nexport var _DYN_TRACE_ID = \"traceId\"; // Count: 5\r\nexport var _DYN_SPAN_ID = \"spanId\"; // Count: 5\r\nexport var _DYN_TRACE_FLAGS = \"traceFlags\"; // Count: 6\r\n//# sourceMappingURL=__DynamicConstants.js.map","// Copyright (c) Microsoft Corporation. All rights reserved.\r\n// Licensed under the MIT License.\r\n// ###################################################################################################################################################\r\n// Note: DON'T Export these const from the package as we are still targeting IE/ES5 this will export a mutable variables that someone could change ###\r\n// ###################################################################################################################################################\r\nexport var UNDEFINED_VALUE = undefined;\r\nexport var STR_EMPTY = \"\";\r\nexport var STR_CHANNELS = \"channels\";\r\nexport var STR_CORE = \"core\";\r\nexport var STR_CREATE_PERF_MGR = \"createPerfMgr\";\r\nexport var STR_DISABLED = \"disabled\";\r\nexport var STR_EXTENSION_CONFIG = \"extensionConfig\";\r\nexport var STR_EXTENSIONS = \"extensions\";\r\nexport var STR_PROCESS_TELEMETRY = \"processTelemetry\";\r\nexport var STR_PRIORITY = \"priority\";\r\nexport var STR_EVENTS_SENT = \"eventsSent\";\r\nexport var STR_EVENTS_DISCARDED = \"eventsDiscarded\";\r\nexport var STR_EVENTS_SEND_REQUEST = \"eventsSendRequest\";\r\nexport var STR_PERF_EVENT = \"perfEvent\";\r\nexport var STR_GET_PERF_MGR = \"getPerfMgr\";\r\nexport var STR_DOMAIN = \"domain\";\r\nexport var STR_PATH = \"path\";\r\nexport var STR_NOT_DYNAMIC_ERROR = \"Not dynamic - \";\r\n//# sourceMappingURL=InternalConstants.js.map","// Copyright (c) Microsoft Corporation. All rights reserved.\r\n// Licensed under the MIT License.\r\nimport { ObjAssign, ObjClass } from \"@microsoft/applicationinsights-shims\";\r\nimport { arrForEach, asString as asString21, isArray, isBoolean, isError, isFunction, isNullOrUndefined, isObject, isPlainObject, isString, isUndefined, objDeepFreeze, objDefine, objForEachKey, objHasOwn, strIndexOf } from \"@nevware21/ts-utils\";\r\nimport { _DYN_APPLY, _DYN_LENGTH, _DYN_NAME, _DYN_REPLACE } from \"../__DynamicConstants\";\r\nimport { STR_EMPTY } from \"./InternalConstants\";\r\n// RESTRICT and AVOID circular dependencies you should not import other contained modules or export the contents of this file directly\r\n// Added to help with minification\r\nvar strGetPrototypeOf = \"getPrototypeOf\";\r\nvar rCamelCase = /-([a-z])/g;\r\nvar rNormalizeInvalid = /([^\\w\\d_$])/g;\r\nvar rLeadingNumeric = /^(\\d+[\\w\\d_$])/;\r\nexport var _getObjProto = Object[strGetPrototypeOf];\r\nexport function isNotUndefined(value) {\r\n    return !isUndefined(value);\r\n}\r\nexport function isNotNullOrUndefined(value) {\r\n    return !isNullOrUndefined(value);\r\n}\r\n/**\r\n * Validates that the string name conforms to the JS IdentifierName specification and if not\r\n * normalizes the name so that it would. This method does not identify or change any keywords\r\n * meaning that if you pass in a known keyword the same value will be returned.\r\n * This is a simplified version\r\n * @param name - The name to validate\r\n */\r\nexport function normalizeJsName(name) {\r\n    var value = name;\r\n    if (value && isString(value)) {\r\n        // CamelCase everything after the \"-\" and remove the dash\r\n        value = value[_DYN_REPLACE /* @min:%2ereplace */](rCamelCase, function (_all, letter) {\r\n            return letter.toUpperCase();\r\n        });\r\n        value = value[_DYN_REPLACE /* @min:%2ereplace */](rNormalizeInvalid, \"_\");\r\n        value = value[_DYN_REPLACE /* @min:%2ereplace */](rLeadingNumeric, function (_all, match) {\r\n            return \"_\" + match;\r\n        });\r\n    }\r\n    return value;\r\n}\r\n/**\r\n * A simple wrapper (for minification support) to check if the value contains the search string.\r\n * @param value - The string value to check for the existence of the search value\r\n * @param search - The value search within the value\r\n */\r\nexport function strContains(value, search) {\r\n    if (value && search) {\r\n        return strIndexOf(value, search) !== -1;\r\n    }\r\n    return false;\r\n}\r\n/**\r\n * Convert a date to I.S.O. format in IE8\r\n */\r\nexport function toISOString(date) {\r\n    return date && date.toISOString() || \"\";\r\n}\r\nexport var deepFreeze = objDeepFreeze;\r\n/**\r\n * Returns the name of object if it's an Error. Otherwise, returns empty string.\r\n */\r\nexport function getExceptionName(object) {\r\n    if (isError(object)) {\r\n        return object[_DYN_NAME /* @min:%2ename */];\r\n    }\r\n    return STR_EMPTY;\r\n}\r\n/**\r\n * Sets the provided value on the target instance using the field name when the provided chk function returns true, the chk\r\n * function will only be called if the new value is no equal to the original value.\r\n * @param target - The target object\r\n * @param field - The key of the target\r\n * @param value - The value to set\r\n * @param valChk - [Optional] Callback to check the value that if supplied will be called check if the new value can be set\r\n * @param srcChk - [Optional] Callback to check to original value that if supplied will be called if the new value should be set (if allowed)\r\n * @returns The existing or new value, depending what was set\r\n */\r\nexport function setValue(target, field, value, valChk, srcChk) {\r\n    var theValue = value;\r\n    if (target) {\r\n        theValue = target[field];\r\n        if (theValue !== value && (!srcChk || srcChk(theValue)) && (!valChk || valChk(value))) {\r\n            theValue = value;\r\n            target[field] = theValue;\r\n        }\r\n    }\r\n    return theValue;\r\n}\r\n/**\r\n * Returns the current value from the target object if not null or undefined otherwise sets the new value and returns it\r\n * @param target - The target object to return or set the default value\r\n * @param field - The key for the field to set on the target\r\n * @param defValue - [Optional] The value to set if not already present, when not provided a empty object will be added\r\n */\r\nexport function getSetValue(target, field, defValue) {\r\n    var theValue;\r\n    if (target) {\r\n        theValue = target[field];\r\n        if (!theValue && isNullOrUndefined(theValue)) {\r\n            // Supports having the default as null\r\n            theValue = !isUndefined(defValue) ? defValue : {};\r\n            target[field] = theValue;\r\n        }\r\n    }\r\n    else {\r\n        // Expanded for performance so we only check defValue if required\r\n        theValue = !isUndefined(defValue) ? defValue : {};\r\n    }\r\n    return theValue;\r\n}\r\nfunction _createProxyFunction(source, funcName) {\r\n    var srcFunc = null;\r\n    var src = null;\r\n    if (isFunction(source)) {\r\n        srcFunc = source;\r\n    }\r\n    else {\r\n        src = source;\r\n    }\r\n    return function () {\r\n        // Capture the original arguments passed to the method\r\n        var originalArguments = arguments;\r\n        if (srcFunc) {\r\n            src = srcFunc();\r\n        }\r\n        if (src) {\r\n            return src[funcName][_DYN_APPLY /* @min:%2eapply */](src, originalArguments);\r\n        }\r\n    };\r\n}\r\n/**\r\n * Effectively assigns all enumerable properties (not just own properties) and functions (including inherited prototype) from\r\n * the source object to the target, it attempts to use proxy getters / setters (if possible) and proxy functions to avoid potential\r\n * implementation issues by assigning prototype functions as instance ones\r\n *\r\n * This method is the primary method used to \"update\" the snippet proxy with the ultimate implementations.\r\n *\r\n * Special ES3 Notes:\r\n * Updates (setting) of direct property values on the target or indirectly on the source object WILL NOT WORK PROPERLY, updates to the\r\n * properties of \"referenced\" object will work (target.context.newValue = 10 => will be reflected in the source.context as it's the\r\n * same object). ES3 Failures: assigning target.myProp = 3 -> Won't change source.myProp = 3, likewise the reverse would also fail.\r\n * @param target - The target object to be assigned with the source properties and functions\r\n * @param source - The source object which will be assigned / called by setting / calling the targets proxies\r\n * @param chkSet - An optional callback to determine whether a specific property/function should be proxied\r\n */\r\nexport function proxyAssign(target, source, chkSet) {\r\n    if (target && source && isObject(target) && isObject(source)) {\r\n        var _loop_1 = function (field) {\r\n            if (isString(field)) {\r\n                var value = source[field];\r\n                if (isFunction(value)) {\r\n                    if (!chkSet || chkSet(field, true, source, target)) {\r\n                        // Create a proxy function rather than just copying the (possible) prototype to the new object as an instance function\r\n                        target[field] = _createProxyFunction(source, field);\r\n                    }\r\n                }\r\n                else if (!chkSet || chkSet(field, false, source, target)) {\r\n                    if (objHasOwn(target, field)) {\r\n                        // Remove any previous instance property\r\n                        delete target[field];\r\n                    }\r\n                    objDefine(target, field, {\r\n                        g: function () {\r\n                            return source[field];\r\n                        },\r\n                        s: function (theValue) {\r\n                            source[field] = theValue;\r\n                        }\r\n                    });\r\n                }\r\n            }\r\n        };\r\n        // effectively apply/proxy full source to the target instance\r\n        for (var field in source) {\r\n            _loop_1(field);\r\n        }\r\n    }\r\n    return target;\r\n}\r\n/**\r\n * Creates a proxy function on the target which internally will call the source version with all arguments passed to the target method.\r\n *\r\n * @param target - The target object to be assigned with the source properties and functions\r\n * @param name - The function name that will be added on the target\r\n * @param source - The source object which will be assigned / called by setting / calling the targets proxies\r\n * @param theFunc - The function name on the source that will be proxied on the target\r\n * @param overwriteTarget - If `false` this will not replace any pre-existing name otherwise (the default) it will overwrite any existing name\r\n */\r\nexport function proxyFunctionAs(target, name, source, theFunc, overwriteTarget) {\r\n    if (target && name && source) {\r\n        if (overwriteTarget !== false || isUndefined(target[name])) {\r\n            target[name] = _createProxyFunction(source, theFunc);\r\n        }\r\n    }\r\n}\r\n/**\r\n * Creates proxy functions on the target which internally will call the source version with all arguments passed to the target method.\r\n *\r\n * @param target - The target object to be assigned with the source properties and functions\r\n * @param source - The source object which will be assigned / called by setting / calling the targets proxies\r\n * @param functionsToProxy - An array of function names that will be proxied on the target\r\n * @param overwriteTarget - If false this will not replace any pre-existing name otherwise (the default) it will overwrite any existing name\r\n */\r\nexport function proxyFunctions(target, source, functionsToProxy, overwriteTarget) {\r\n    if (target && source && isObject(target) && isArray(functionsToProxy)) {\r\n        arrForEach(functionsToProxy, function (theFuncName) {\r\n            if (isString(theFuncName)) {\r\n                proxyFunctionAs(target, theFuncName, source, theFuncName, overwriteTarget);\r\n            }\r\n        });\r\n    }\r\n    return target;\r\n}\r\n/**\r\n * Simpler helper to create a dynamic class that implements the interface and populates the values with the defaults.\r\n * Only instance properties (hasOwnProperty) values are copied from the defaults to the new instance\r\n * @param defaults - Simple helper\r\n */\r\nexport function createClassFromInterface(defaults) {\r\n    return /** @class */ (function () {\r\n        function class_1() {\r\n            var _this = this;\r\n            if (defaults) {\r\n                objForEachKey(defaults, function (field, value) {\r\n                    _this[field] = value;\r\n                });\r\n            }\r\n        }\r\n        return class_1;\r\n    }());\r\n}\r\n/**\r\n * A helper function to assist with JIT performance for objects that have properties added / removed dynamically\r\n * this is primarily for chromium based browsers and has limited effects on Firefox and none of IE. Only call this\r\n * function after you have finished \"updating\" the object, calling this within loops reduces or defeats the benefits.\r\n * This helps when iterating using for..in, objKeys() and objForEach()\r\n * @param theObject - The object to be optimized if possible\r\n */\r\nexport function optimizeObject(theObject) {\r\n    // V8 Optimization to cause the JIT compiler to create a new optimized object for looking up the own properties\r\n    // primarily for object with <= 19 properties for >= 20 the effect is reduced or non-existent\r\n    if (theObject && ObjAssign) {\r\n        theObject = ObjClass(ObjAssign({}, theObject));\r\n    }\r\n    return theObject;\r\n}\r\nexport function objExtend(obj1, obj2, obj3, obj4, obj5, obj6) {\r\n    // Variables\r\n    var theArgs = arguments;\r\n    var extended = theArgs[0] || {};\r\n    var argLen = theArgs[_DYN_LENGTH /* @min:%2elength */];\r\n    var deep = false;\r\n    var idx = 1;\r\n    // Check for \"Deep\" flag\r\n    if (argLen > 0 && isBoolean(extended)) {\r\n        deep = extended;\r\n        extended = theArgs[idx] || {};\r\n        idx++;\r\n    }\r\n    // Handle case when target is a string or something (possible in deep copy)\r\n    if (!isObject(extended)) {\r\n        extended = {};\r\n    }\r\n    // Loop through each remaining object and conduct a merge\r\n    for (; idx < argLen; idx++) {\r\n        var arg = theArgs[idx];\r\n        var isArgArray = isArray(arg);\r\n        var isArgObj = isObject(arg);\r\n        for (var prop in arg) {\r\n            var propOk = (isArgArray && (prop in arg)) || (isArgObj && objHasOwn(arg, prop));\r\n            if (!propOk) {\r\n                continue;\r\n            }\r\n            var newValue = arg[prop];\r\n            var isNewArray = void 0;\r\n            // If deep merge and property is an object, merge properties\r\n            if (deep && newValue && ((isNewArray = isArray(newValue)) || isPlainObject(newValue))) {\r\n                // Grab the current value of the extended object\r\n                var clone = extended[prop];\r\n                if (isNewArray) {\r\n                    if (!isArray(clone)) {\r\n                        // We can't \"merge\" an array with a non-array so overwrite the original\r\n                        clone = [];\r\n                    }\r\n                }\r\n                else if (!isPlainObject(clone)) {\r\n                    // We can't \"merge\" an object with a non-object\r\n                    clone = {};\r\n                }\r\n                // Never move the original objects always clone them\r\n                newValue = objExtend(deep, clone, newValue);\r\n            }\r\n            // Assign the new (or previous) value (unless undefined)\r\n            if (newValue !== undefined) {\r\n                extended[prop] = newValue;\r\n            }\r\n        }\r\n    }\r\n    return extended;\r\n}\r\nexport var asString = asString21;\r\n//# sourceMappingURL=HelperFuncs.js.map","// Copyright (c) Microsoft Corporation. All rights reserved.\r\n// Licensed under the MIT License.\r\n\r\nexport const strShimFunction = \"function\";\r\nexport const strShimObject = \"object\";\r\nexport const strShimUndefined = \"undefined\";\r\nexport const strShimPrototype = \"prototype\";\r\nexport const strDefault = \"default\";\r\n\r\nexport const ObjClass = Object;\r\nexport const ObjProto = ObjClass[strShimPrototype];\r\n","// Copyright (c) Microsoft Corporation. All rights reserved.\r\n// Licensed under the MIT License.\r\n\"use strict\";\r\nimport { strShimObject, strShimPrototype, strShimUndefined } from \"@microsoft/applicationinsights-shims\";\r\nimport { getDocument, getInst, getNavigator, getPerformance, hasNavigator, isString, isUndefined, strIndexOf } from \"@nevware21/ts-utils\";\r\nimport { _DYN_LENGTH, _DYN_NAME, _DYN_SPLIT, _DYN_TO_LOWER_CASE, _DYN_USER_AGENT } from \"../__DynamicConstants\";\r\nimport { strContains } from \"./HelperFuncs\";\r\nimport { STR_EMPTY } from \"./InternalConstants\";\r\n/**\r\n * This file exists to hold environment utilities that are required to check and\r\n * validate the current operating environment. Unless otherwise required, please\r\n * only use defined methods (functions) in this class so that users of these\r\n * functions/properties only need to include those that are used within their own modules.\r\n */\r\nvar strDocumentMode = \"documentMode\";\r\nvar strLocation = \"location\";\r\nvar strConsole = \"console\";\r\nvar strPerformance = \"performance\";\r\nvar strJSON = \"JSON\";\r\nvar strCrypto = \"crypto\";\r\nvar strMsCrypto = \"msCrypto\";\r\nvar strReactNative = \"ReactNative\";\r\nvar strMsie = \"msie\";\r\nvar strTrident = \"trident/\";\r\nvar strXMLHttpRequest = \"XMLHttpRequest\";\r\nvar _isTrident = null;\r\nvar _navUserAgentCheck = null;\r\nvar _enableMocks = false;\r\nvar _useXDomainRequest = null;\r\nvar _beaconsSupported = null;\r\nfunction _hasProperty(theClass, property) {\r\n    var supported = false;\r\n    if (theClass) {\r\n        try {\r\n            supported = property in theClass;\r\n            if (!supported) {\r\n                var proto = theClass[strShimPrototype];\r\n                if (proto) {\r\n                    supported = property in proto;\r\n                }\r\n            }\r\n        }\r\n        catch (e) {\r\n            // Do Nothing\r\n        }\r\n        if (!supported) {\r\n            try {\r\n                var tmp = new theClass();\r\n                supported = !isUndefined(tmp[property]);\r\n            }\r\n            catch (e) {\r\n                // Do Nothing\r\n            }\r\n        }\r\n    }\r\n    return supported;\r\n}\r\n/**\r\n * Enable the lookup of test mock objects if requested\r\n * @param enabled\r\n */\r\nexport function setEnableEnvMocks(enabled) {\r\n    _enableMocks = enabled;\r\n}\r\n/**\r\n * Returns the global location object if it is present otherwise null.\r\n * This helper is used to access the location object without causing an exception\r\n * \"Uncaught ReferenceError: location is not defined\"\r\n */\r\nexport function getLocation(checkForMock) {\r\n    if (checkForMock && _enableMocks) {\r\n        var mockLocation = getInst(\"__mockLocation\");\r\n        if (mockLocation) {\r\n            return mockLocation;\r\n        }\r\n    }\r\n    if (typeof location === strShimObject && location) {\r\n        return location;\r\n    }\r\n    return getInst(strLocation);\r\n}\r\n/**\r\n * Returns the global console object\r\n */\r\nexport function getConsole() {\r\n    if (typeof console !== strShimUndefined) {\r\n        return console;\r\n    }\r\n    return getInst(strConsole);\r\n}\r\n/**\r\n * Checks if JSON object is available, this is required as we support the API running without a\r\n * window /document (eg. Node server, electron webworkers) and if we attempt to assign a history\r\n * object to a local variable or pass as an argument an \"Uncaught ReferenceError: JSON is not defined\"\r\n * exception will be thrown.\r\n * Defined as a function to support lazy / late binding environments.\r\n */\r\nexport function hasJSON() {\r\n    return Boolean((typeof JSON === strShimObject && JSON) || getInst(strJSON) !== null);\r\n}\r\n/**\r\n * Returns the global JSON object if it is present otherwise null.\r\n * This helper is used to access the JSON object without causing an exception\r\n * \"Uncaught ReferenceError: JSON is not defined\"\r\n */\r\nexport function getJSON() {\r\n    if (hasJSON()) {\r\n        return JSON || getInst(strJSON);\r\n    }\r\n    return null;\r\n}\r\n/**\r\n * Returns the crypto object if it is present otherwise null.\r\n * This helper is used to access the crypto object from the current\r\n * global instance which could be window or globalThis for a web worker\r\n */\r\nexport function getCrypto() {\r\n    return getInst(strCrypto);\r\n}\r\n/**\r\n * Returns the crypto object if it is present otherwise null.\r\n * This helper is used to access the crypto object from the current\r\n * global instance which could be window or globalThis for a web worker\r\n */\r\nexport function getMsCrypto() {\r\n    return getInst(strMsCrypto);\r\n}\r\n/**\r\n * Returns whether the environment is reporting that we are running in a React Native Environment\r\n */\r\nexport function isReactNative() {\r\n    // If running in React Native, navigator.product will be populated\r\n    var nav = getNavigator();\r\n    if (nav && nav.product) {\r\n        return nav.product === strReactNative;\r\n    }\r\n    return false;\r\n}\r\n/**\r\n * Identifies whether the current environment appears to be IE\r\n */\r\nexport function isIE() {\r\n    var nav = getNavigator();\r\n    if (nav && (nav[_DYN_USER_AGENT /* @min:%2euserAgent */] !== _navUserAgentCheck || _isTrident === null)) {\r\n        // Added to support test mocking of the user agent\r\n        _navUserAgentCheck = nav[_DYN_USER_AGENT /* @min:%2euserAgent */];\r\n        var userAgent = (_navUserAgentCheck || STR_EMPTY)[_DYN_TO_LOWER_CASE /* @min:%2etoLowerCase */]();\r\n        _isTrident = (strContains(userAgent, strMsie) || strContains(userAgent, strTrident));\r\n    }\r\n    return _isTrident;\r\n}\r\n/**\r\n * Gets IE version returning the document emulation mode if we are running on IE, or null otherwise\r\n */\r\nexport function getIEVersion(userAgentStr) {\r\n    if (userAgentStr === void 0) { userAgentStr = null; }\r\n    if (!userAgentStr) {\r\n        var navigator_1 = getNavigator() || {};\r\n        userAgentStr = navigator_1 ? (navigator_1.userAgent || STR_EMPTY)[_DYN_TO_LOWER_CASE /* @min:%2etoLowerCase */]() : STR_EMPTY;\r\n    }\r\n    var ua = (userAgentStr || STR_EMPTY)[_DYN_TO_LOWER_CASE /* @min:%2etoLowerCase */]();\r\n    // Also check for documentMode in case X-UA-Compatible meta tag was included in HTML.\r\n    if (strContains(ua, strMsie)) {\r\n        var doc = getDocument() || {};\r\n        return Math.max(parseInt(ua[_DYN_SPLIT /* @min:%2esplit */](strMsie)[1]), (doc[strDocumentMode] || 0));\r\n    }\r\n    else if (strContains(ua, strTrident)) {\r\n        var tridentVer = parseInt(ua[_DYN_SPLIT /* @min:%2esplit */](strTrident)[1]);\r\n        if (tridentVer) {\r\n            return tridentVer + 4;\r\n        }\r\n    }\r\n    return null;\r\n}\r\nexport function isSafari(userAgentStr) {\r\n    if (!userAgentStr || !isString(userAgentStr)) {\r\n        var navigator_2 = getNavigator() || {};\r\n        userAgentStr = navigator_2 ? (navigator_2.userAgent || STR_EMPTY)[_DYN_TO_LOWER_CASE /* @min:%2etoLowerCase */]() : STR_EMPTY;\r\n    }\r\n    var ua = (userAgentStr || STR_EMPTY)[_DYN_TO_LOWER_CASE /* @min:%2etoLowerCase */]();\r\n    return (strIndexOf(ua, \"safari\") >= 0);\r\n}\r\n/**\r\n * Checks if HTML5 Beacons are supported in the current environment.\r\n * @returns True if supported, false otherwise.\r\n */\r\nexport function isBeaconsSupported() {\r\n    if (_beaconsSupported === null) {\r\n        _beaconsSupported = hasNavigator() && Boolean(getNavigator().sendBeacon);\r\n    }\r\n    return _beaconsSupported;\r\n}\r\n/**\r\n * Checks if the Fetch API is supported in the current environment.\r\n * @param withKeepAlive - [Optional] If True, check if fetch is available and it supports the keepalive feature, otherwise only check if fetch is supported\r\n * @returns True if supported, otherwise false\r\n */\r\nexport function isFetchSupported(withKeepAlive) {\r\n    var isSupported = false;\r\n    try {\r\n        isSupported = !!getInst(\"fetch\");\r\n        var request = getInst(\"Request\");\r\n        if (isSupported && withKeepAlive && request) {\r\n            isSupported = _hasProperty(request, \"keepalive\");\r\n        }\r\n    }\r\n    catch (e) {\r\n        // Just Swallow any failure during availability checks\r\n    }\r\n    return isSupported;\r\n}\r\nexport function useXDomainRequest() {\r\n    if (_useXDomainRequest === null) {\r\n        _useXDomainRequest = (typeof XDomainRequest !== strShimUndefined);\r\n        if (_useXDomainRequest && isXhrSupported()) {\r\n            _useXDomainRequest = _useXDomainRequest && !_hasProperty(getInst(strXMLHttpRequest), \"withCredentials\");\r\n        }\r\n    }\r\n    return _useXDomainRequest;\r\n}\r\n/**\r\n * Checks if XMLHttpRequest is supported\r\n * @returns True if supported, otherwise false\r\n */\r\nexport function isXhrSupported() {\r\n    var isSupported = false;\r\n    try {\r\n        var xmlHttpRequest = getInst(strXMLHttpRequest);\r\n        isSupported = !!xmlHttpRequest;\r\n    }\r\n    catch (e) {\r\n        // Just Swallow any failure during availability checks\r\n    }\r\n    return isSupported;\r\n}\r\nfunction _getNamedValue(values, name) {\r\n    if (values) {\r\n        for (var i = 0; i < values[_DYN_LENGTH /* @min:%2elength */]; i++) {\r\n            var value = values[i];\r\n            if (value[_DYN_NAME /* @min:%2ename */]) {\r\n                if (value[_DYN_NAME /* @min:%2ename */] === name) {\r\n                    return value;\r\n                }\r\n            }\r\n        }\r\n    }\r\n    return {};\r\n}\r\n/**\r\n * Helper function to fetch the named meta-tag from the page.\r\n * @param name\r\n */\r\nexport function findMetaTag(name) {\r\n    var doc = getDocument();\r\n    if (doc && name) {\r\n        // Look for a meta-tag\r\n        return _getNamedValue(doc.querySelectorAll(\"meta\"), name).content;\r\n    }\r\n    return null;\r\n}\r\n/**\r\n * Helper function to fetch the named server timing value from the page response (first navigation event).\r\n * @param name\r\n */\r\nexport function findNamedServerTiming(name) {\r\n    var value;\r\n    var perf = getPerformance();\r\n    if (perf) {\r\n        // Try looking for a server-timing header\r\n        var navPerf = perf.getEntriesByType(\"navigation\") || [];\r\n        value = _getNamedValue((navPerf[_DYN_LENGTH /* @min:%2elength */] > 0 ? navPerf[0] : {}).serverTiming, name).description;\r\n    }\r\n    return value;\r\n}\r\n//# sourceMappingURL=EnvUtils.js.map","// Copyright (c) Microsoft Corporation. All rights reserved.\r\n// Licensed under the MIT License.\r\nimport { utcNow } from \"@nevware21/ts-utils\";\r\nimport { _DYN_LENGTH } from \"../__DynamicConstants\";\r\nimport { getCrypto, getMsCrypto, isIE } from \"./EnvUtils\";\r\nimport { STR_EMPTY } from \"./InternalConstants\";\r\nvar UInt32Mask = 0x100000000;\r\nvar MaxUInt32 = 0xffffffff;\r\nvar SEED1 = 123456789;\r\nvar SEED2 = 987654321;\r\n// MWC based Random generator (for IE)\r\nvar _mwcSeeded = false;\r\nvar _mwcW = SEED1;\r\nvar _mwcZ = SEED2;\r\n// Takes any integer\r\nfunction _mwcSeed(seedValue) {\r\n    if (seedValue < 0) {\r\n        // Make sure we end up with a positive number and not -ve one.\r\n        seedValue >>>= 0;\r\n    }\r\n    _mwcW = (SEED1 + seedValue) & MaxUInt32;\r\n    _mwcZ = (SEED2 - seedValue) & MaxUInt32;\r\n    _mwcSeeded = true;\r\n}\r\nfunction _autoSeedMwc() {\r\n    // Simple initialization using default Math.random() - So we inherit any entropy from the browser\r\n    // and bitwise XOR with the current milliseconds\r\n    try {\r\n        var now = utcNow() & 0x7fffffff;\r\n        _mwcSeed(((Math.random() * UInt32Mask) ^ now) + now);\r\n    }\r\n    catch (e) {\r\n        // Don't crash if something goes wrong\r\n    }\r\n}\r\n/**\r\n * Generate a random value between 0 and maxValue, max value should be limited to a 32-bit maximum.\r\n * So maxValue(16) will produce a number from 0..16 (range of 17)\r\n * @param maxValue\r\n */\r\nexport function randomValue(maxValue) {\r\n    if (maxValue > 0) {\r\n        return Math.floor((random32() / MaxUInt32) * (maxValue + 1)) >>> 0;\r\n    }\r\n    return 0;\r\n}\r\n/**\r\n * generate a random 32-bit number (0x000000..0xFFFFFFFF) or (-0x80000000..0x7FFFFFFF), defaults un-unsigned.\r\n * @param signed - True to return a signed 32-bit number (-0x80000000..0x7FFFFFFF) otherwise an unsigned one (0x000000..0xFFFFFFFF)\r\n */\r\nexport function random32(signed) {\r\n    var value = 0;\r\n    var c = getCrypto() || getMsCrypto();\r\n    if (c && c.getRandomValues) {\r\n        // Make sure the number is converted into the specified range (-0x80000000..0x7FFFFFFF)\r\n        value = c.getRandomValues(new Uint32Array(1))[0] & MaxUInt32;\r\n    }\r\n    if (value === 0 && isIE()) {\r\n        // For IE 6, 7, 8 (especially on XP) Math.random is not very random\r\n        if (!_mwcSeeded) {\r\n            // Set the seed for the Mwc algorithm\r\n            _autoSeedMwc();\r\n        }\r\n        // Don't use Math.random for IE\r\n        // Make sure the number is converted into the specified range (-0x80000000..0x7FFFFFFF)\r\n        value = mwcRandom32() & MaxUInt32;\r\n    }\r\n    if (value === 0) {\r\n        // Make sure the number is converted into the specified range (-0x80000000..0x7FFFFFFF)\r\n        value = Math.floor((UInt32Mask * Math.random()) | 0);\r\n    }\r\n    if (!signed) {\r\n        // Make sure we end up with a positive number and not -ve one.\r\n        value >>>= 0;\r\n    }\r\n    return value;\r\n}\r\n/**\r\n * Seed the MWC random number generator with the specified seed or a random value\r\n * @param value - optional the number to used as the seed, if undefined, null or zero a random value will be chosen\r\n */\r\nexport function mwcRandomSeed(value) {\r\n    if (!value) {\r\n        _autoSeedMwc();\r\n    }\r\n    else {\r\n        _mwcSeed(value);\r\n    }\r\n}\r\n/**\r\n * Generate a random 32-bit number between (0x000000..0xFFFFFFFF) or (-0x80000000..0x7FFFFFFF), using MWC (Multiply with carry)\r\n * instead of Math.random() defaults to un-signed.\r\n * Used as a replacement random generator for IE to avoid issues with older IE instances.\r\n * @param signed - True to return a signed 32-bit number (-0x80000000..0x7FFFFFFF) otherwise an unsigned one (0x000000..0xFFFFFFFF)\r\n */\r\nexport function mwcRandom32(signed) {\r\n    _mwcZ = (36969 * (_mwcZ & 0xFFFF) + (_mwcZ >> 16)) & MaxUInt32;\r\n    _mwcW = (18000 * (_mwcW & 0xFFFF) + (_mwcW >> 16)) & MaxUInt32;\r\n    var value = (((_mwcZ << 16) + (_mwcW & 0xFFFF)) >>> 0) & MaxUInt32 | 0;\r\n    if (!signed) {\r\n        // Make sure we end up with a positive number and not -ve one.\r\n        value >>>= 0;\r\n    }\r\n    return value;\r\n}\r\n/**\r\n * Generate random base64 id string.\r\n * The default length is 22 which is 132-bits so almost the same as a GUID but as base64 (the previous default was 5)\r\n * @param maxLength - Optional value to specify the length of the id to be generated, defaults to 22\r\n */\r\nexport function newId(maxLength) {\r\n    if (maxLength === void 0) { maxLength = 22; }\r\n    var base64chars = \"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/\";\r\n    // Start with an initial random number, consuming the value in reverse byte order\r\n    var number = random32() >>> 0; // Make sure it's a +ve number\r\n    var chars = 0;\r\n    var result = STR_EMPTY;\r\n    while (result[_DYN_LENGTH /* @min:%2elength */] < maxLength) {\r\n        chars++;\r\n        result += base64chars.charAt(number & 0x3F);\r\n        number >>>= 6; // Zero fill with right shift\r\n        if (chars === 5) {\r\n            // 5 base64 characters === 30 bits so we don't have enough bits for another base64 char\r\n            // So add on another 30 bits and make sure it's +ve\r\n            number = (((random32() << 2) & 0xFFFFFFFF) | (number & 0x03)) >>> 0;\r\n            chars = 0; // We need to reset the number every 5 chars (30 bits)\r\n        }\r\n    }\r\n    return result;\r\n}\r\n//# sourceMappingURL=RandomHelper.js.map","// Copyright (c) Microsoft Corporation. All rights reserved.\r\n// Licensed under the MIT License.\r\nimport { objDefine } from \"@nevware21/ts-utils\";\r\nimport { _DYN_NODE_TYPE } from \"../__DynamicConstants\";\r\nimport { normalizeJsName } from \"./HelperFuncs\";\r\nimport { STR_EMPTY } from \"./InternalConstants\";\r\nimport { newId } from \"./RandomHelper\";\r\nvar version = '3.0.2';\r\nvar instanceName = \".\" + newId(6);\r\nvar _dataUid = 0;\r\n// Accepts only:\r\n//  - Node\r\n//    - Node.ELEMENT_NODE\r\n//    - Node.DOCUMENT_NODE\r\n//  - Object\r\n//    - Any\r\nfunction _canAcceptData(target) {\r\n    return target[_DYN_NODE_TYPE /* @min:%2enodeType */] === 1 || target[_DYN_NODE_TYPE /* @min:%2enodeType */] === 9 || !(+target[_DYN_NODE_TYPE /* @min:%2enodeType */]);\r\n}\r\nfunction _getCache(data, target) {\r\n    var theCache = target[data.id];\r\n    if (!theCache) {\r\n        theCache = {};\r\n        try {\r\n            if (_canAcceptData(target)) {\r\n                objDefine(target, data.id, {\r\n                    e: false,\r\n                    v: theCache\r\n                });\r\n            }\r\n        }\r\n        catch (e) {\r\n            // Not all environments allow extending all objects, so just ignore the cache in those cases\r\n        }\r\n    }\r\n    return theCache;\r\n}\r\nexport function createUniqueNamespace(name, includeVersion) {\r\n    if (includeVersion === void 0) { includeVersion = false; }\r\n    return normalizeJsName(name + (_dataUid++) + (includeVersion ? \".\" + version : STR_EMPTY) + instanceName);\r\n}\r\nexport function createElmNodeData(name) {\r\n    var data = {\r\n        id: createUniqueNamespace(\"_aiData-\" + (name || STR_EMPTY) + \".\" + version),\r\n        accept: function (target) {\r\n            return _canAcceptData(target);\r\n        },\r\n        get: function (target, name, defValue, addDefault) {\r\n            var theCache = target[data.id];\r\n            if (!theCache) {\r\n                if (addDefault) {\r\n                    // Side effect is adds the cache\r\n                    theCache = _getCache(data, target);\r\n                    theCache[normalizeJsName(name)] = defValue;\r\n                }\r\n                return defValue;\r\n            }\r\n            return theCache[normalizeJsName(name)];\r\n        },\r\n        kill: function (target, name) {\r\n            if (target && target[name]) {\r\n                try {\r\n                    delete target[name];\r\n                }\r\n                catch (e) {\r\n                    // Just cleaning up, so if this fails -- ignore\r\n                }\r\n            }\r\n        }\r\n    };\r\n    return data;\r\n}\r\n//# sourceMappingURL=DataCacheHelper.js.map","// Copyright (c) Microsoft Corporation. All rights reserved.\r\n// Licensed under the MIT License.\r\nimport { asString, isArray, isDefined, isNullOrUndefined, isObject, isPlainObject, isUndefined, objForEachKey, objHasOwn } from \"@nevware21/ts-utils\";\r\nimport { _DYN_BLK_VAL, _DYN_LENGTH, _DYN_RD_ONLY } from \"../__DynamicConstants\";\r\nfunction _isConfigDefaults(value) {\r\n    return (value && isObject(value) && (value.isVal || value.fb || objHasOwn(value, \"v\") || objHasOwn(value, \"mrg\") || objHasOwn(value, \"ref\") || value.set));\r\n}\r\nfunction _getDefault(dynamicHandler, theConfig, cfgDefaults) {\r\n    var defValue;\r\n    var isDefaultValid = cfgDefaults.dfVal || isDefined;\r\n    // There is a fallback config key so try and grab that first\r\n    if (theConfig && cfgDefaults.fb) {\r\n        var fallbacks = cfgDefaults.fb;\r\n        if (!isArray(fallbacks)) {\r\n            fallbacks = [fallbacks];\r\n        }\r\n        for (var lp = 0; lp < fallbacks[_DYN_LENGTH /* @min:%2elength */]; lp++) {\r\n            var fallback = fallbacks[lp];\r\n            var fbValue = theConfig[fallback];\r\n            if (isDefaultValid(fbValue)) {\r\n                defValue = fbValue;\r\n            }\r\n            else if (dynamicHandler) {\r\n                // Needed to ensure that the fallback value (and potentially) new field is also dynamic even if null/undefined\r\n                fbValue = dynamicHandler.cfg[fallback];\r\n                if (isDefaultValid(fbValue)) {\r\n                    defValue = fbValue;\r\n                }\r\n                // Needed to ensure that the fallback value (and potentially) new field is also dynamic even if null/undefined\r\n                dynamicHandler.set(dynamicHandler.cfg, asString(fallback), fbValue);\r\n            }\r\n            if (isDefaultValid(defValue)) {\r\n                // We have a valid default so break out of the look\r\n                break;\r\n            }\r\n        }\r\n    }\r\n    // If the value is still not defined and we have a default value then use that\r\n    if (!isDefaultValid(defValue) && isDefaultValid(cfgDefaults.v)) {\r\n        defValue = cfgDefaults.v;\r\n    }\r\n    return defValue;\r\n}\r\n/**\r\n * Recursively resolve the default value\r\n * @param dynamicHandler\r\n * @param theConfig\r\n * @param cfgDefaults\r\n * @returns\r\n */\r\nfunction _resolveDefaultValue(dynamicHandler, theConfig, cfgDefaults) {\r\n    var theValue = cfgDefaults;\r\n    if (cfgDefaults && _isConfigDefaults(cfgDefaults)) {\r\n        theValue = _getDefault(dynamicHandler, theConfig, cfgDefaults);\r\n    }\r\n    if (theValue) {\r\n        if (_isConfigDefaults(theValue)) {\r\n            theValue = _resolveDefaultValue(dynamicHandler, theConfig, theValue);\r\n        }\r\n        var newValue_1;\r\n        if (isArray(theValue)) {\r\n            newValue_1 = [];\r\n            newValue_1[_DYN_LENGTH /* @min:%2elength */] = theValue[_DYN_LENGTH /* @min:%2elength */];\r\n        }\r\n        else if (isPlainObject(theValue)) {\r\n            newValue_1 = {};\r\n        }\r\n        if (newValue_1) {\r\n            objForEachKey(theValue, function (key, value) {\r\n                if (value && _isConfigDefaults(value)) {\r\n                    value = _resolveDefaultValue(dynamicHandler, theConfig, value);\r\n                }\r\n                newValue_1[key] = value;\r\n            });\r\n            theValue = newValue_1;\r\n        }\r\n    }\r\n    return theValue;\r\n}\r\n/**\r\n * Applies the default value on the config property and makes sure that it's dynamic\r\n * @param theConfig\r\n * @param name\r\n * @param defaultValue\r\n */\r\nexport function _applyDefaultValue(dynamicHandler, theConfig, name, defaultValue) {\r\n    // Resolve the initial config value from the provided value or use the defined default\r\n    var isValid;\r\n    var setFn;\r\n    var defValue;\r\n    var cfgDefaults = defaultValue;\r\n    var mergeDf;\r\n    var reference;\r\n    var readOnly;\r\n    var blkDynamicValue;\r\n    if (_isConfigDefaults(cfgDefaults)) {\r\n        // looks like a IConfigDefault\r\n        isValid = cfgDefaults.isVal;\r\n        setFn = cfgDefaults.set;\r\n        readOnly = cfgDefaults[_DYN_RD_ONLY /* @min:%2erdOnly */];\r\n        blkDynamicValue = cfgDefaults[_DYN_BLK_VAL /* @min:%2eblkVal */];\r\n        mergeDf = cfgDefaults.mrg;\r\n        reference = cfgDefaults.ref;\r\n        if (!reference && isUndefined(reference)) {\r\n            reference = !!mergeDf;\r\n        }\r\n        defValue = _getDefault(dynamicHandler, theConfig, cfgDefaults);\r\n    }\r\n    else {\r\n        defValue = defaultValue;\r\n    }\r\n    if (blkDynamicValue) {\r\n        // Mark the property so that any value assigned will be blocked from conversion, we need to do this\r\n        // before assigning or fetching the value to ensure it's not converted\r\n        dynamicHandler[_DYN_BLK_VAL /* @min:%2eblkVal */](theConfig, name);\r\n    }\r\n    // Set the value to the default value;\r\n    var theValue;\r\n    var usingDefault = true;\r\n    var cfgValue = theConfig[name];\r\n    // try and get and user provided values\r\n    if (cfgValue || !isNullOrUndefined(cfgValue)) {\r\n        // Use the defined theConfig[name] value\r\n        theValue = cfgValue;\r\n        usingDefault = false;\r\n        // The values are different and we have a special default value check, which is used to\r\n        // override config values like empty strings to continue using the default\r\n        if (isValid && theValue !== defValue && !isValid(theValue)) {\r\n            theValue = defValue;\r\n            usingDefault = true;\r\n        }\r\n        if (setFn) {\r\n            theValue = setFn(theValue, defValue, theConfig);\r\n            usingDefault = theValue === defValue;\r\n        }\r\n    }\r\n    if (!usingDefault) {\r\n        if (isPlainObject(theValue) || isArray(defValue)) {\r\n            // we are using the user supplied value and it's an object\r\n            if (mergeDf && defValue && (isPlainObject(defValue) || isArray(defValue))) {\r\n                // Resolve/apply the defaults\r\n                objForEachKey(defValue, function (dfName, dfValue) {\r\n                    // Sets the value and makes it dynamic (if it doesn't already exist)\r\n                    _applyDefaultValue(dynamicHandler, theValue, dfName, dfValue);\r\n                });\r\n            }\r\n        }\r\n    }\r\n    else if (defValue) {\r\n        // Just resolve the default\r\n        theValue = _resolveDefaultValue(dynamicHandler, theConfig, defValue);\r\n    }\r\n    else {\r\n        theValue = defValue;\r\n    }\r\n    // if (theValue && usingDefault && (isPlainObject(theValue) || isArray(theValue))) {\r\n    //     theValue = _cfgDeepCopy(theValue);\r\n    // }\r\n    // Needed to ensure that the (potentially) new field is dynamic even if null/undefined\r\n    dynamicHandler.set(theConfig, name, theValue);\r\n    if (reference) {\r\n        dynamicHandler.ref(theConfig, name);\r\n    }\r\n    if (readOnly) {\r\n        dynamicHandler[_DYN_RD_ONLY /* @min:%2erdOnly */](theConfig, name);\r\n    }\r\n}\r\n//# sourceMappingURL=ConfigDefaults.js.map","// Copyright (c) Microsoft Corporation. All rights reserved.\r\n// Licensed under the MIT License.\r\nimport { isArray, isPlainObject, objForEachKey, symbolFor, throwTypeError } from \"@nevware21/ts-utils\";\r\nimport { _DYN_LENGTH } from \"../__DynamicConstants\";\r\n// Using Symbol.for so that if the same symbol was already created it would be returned\r\n// To handle multiple instances using potentially different versions we are not using\r\n// createUniqueNamespace()\r\nexport var CFG_HANDLER_LINK = symbolFor(\"[[ai_dynCfg_1]]\");\r\n/**\r\n * @internal\r\n * @ignore\r\n * The symbol to tag objects / arrays with if they should not be converted\r\n */\r\nvar BLOCK_DYNAMIC = symbolFor(\"[[ai_blkDynCfg_1]]\");\r\n/**\r\n * @internal\r\n * @ignore\r\n * The symbol to tag objects to indicate that when included into the configuration that\r\n * they should be converted into a trackable dynamic object.\r\n */\r\nvar FORCE_DYNAMIC = symbolFor(\"[[ai_frcDynCfg_1]]\");\r\nexport function _cfgDeepCopy(source) {\r\n    if (source) {\r\n        var target_1;\r\n        if (isArray(source)) {\r\n            target_1 = [];\r\n            target_1[_DYN_LENGTH /* @min:%2elength */] = source[_DYN_LENGTH /* @min:%2elength */];\r\n        }\r\n        else if (isPlainObject(source)) {\r\n            target_1 = {};\r\n        }\r\n        if (target_1) {\r\n            // Copying index values by property name as the extensionConfig can be an array or object\r\n            objForEachKey(source, function (key, value) {\r\n                // Perform a deep copy of the object\r\n                target_1[key] = _cfgDeepCopy(value);\r\n            });\r\n            return target_1;\r\n        }\r\n    }\r\n    return source;\r\n}\r\n/**\r\n * @internal\r\n * Get the dynamic config handler if the value is already dynamic\r\n * @param value\r\n * @returns\r\n */\r\nexport function getDynamicConfigHandler(value) {\r\n    if (value) {\r\n        var handler = value[CFG_HANDLER_LINK] || value;\r\n        if (handler.cfg && (handler.cfg === value || handler.cfg[CFG_HANDLER_LINK] === handler)) {\r\n            return handler;\r\n        }\r\n    }\r\n    return null;\r\n}\r\n/**\r\n * Mark the provided value so that if it's included into the configuration it will NOT have\r\n * its properties converted into a dynamic (reactive) object. If the object is not a plain object\r\n * or an array (ie. a class) this function has not affect as only Objects and Arrays are converted\r\n * into dynamic objects in the dynamic configuration.\r\n *\r\n * When you have tagged a value as both {@link forceDynamicConversion} and blocked force will take precedence.\r\n *\r\n * You should only need to use this function, if you are creating dynamic \"classes\" from objects\r\n * which confirm to the require interface. A common case for this is during unit testing where it's\r\n * easier to create mock extensions.\r\n *\r\n * If `value` is falsy (null / undefined / 0 / empty string etc) it will not be tagged and\r\n * if there is an exception adding the property to the value (because its frozen etc) the\r\n * exception will be swallowed\r\n *\r\n * @example\r\n * ```ts\r\n * // This is a valid \"extension\", but it is technically an object\r\n * // So when included in the config.extensions it WILL be cloned and then\r\n * // converted into a dynamic object, where all of its properties will become\r\n * // get/set object properties and will be tracked. While this WILL still\r\n * // function, when attempt to use a mocking framework on top of this the\r\n * // functions are now technically get accessors which return a function\r\n * // and this can cause some mocking frameworks to fail.\r\n * let mockChannel = {\r\n *      pause: () => { },\r\n*      resume: () => { },\r\n*      teardown: () => { },\r\n*      flush: (async: any, callBack: any) => { },\r\n*      processTelemetry: (env: any) => { },\r\n*      setNextPlugin: (next: any) => { },\r\n*      initialize: (config: any, core: any, extensions: any) => { },\r\n*      identifier: \"testChannel\",\r\n*      priority: 1003\r\n* };\r\n * ```\r\n * @param value - The object that you want to block from being converted into a\r\n * trackable dynamic object\r\n * @returns The original value\r\n */\r\nexport function blockDynamicConversion(value) {\r\n    if (value && (isPlainObject(value) || isArray(value))) {\r\n        try {\r\n            value[BLOCK_DYNAMIC] = true;\r\n        }\r\n        catch (e) {\r\n            // Don't throw for this case as it's an ask only\r\n        }\r\n    }\r\n    return value;\r\n}\r\n/**\r\n * This is the reverse case of {@link blockDynamicConversion} in that this will tag an\r\n * object to indicate that it should always be converted into a dynamic trackable object\r\n * even when not an object or array. So all properties of this object will become\r\n * get / set accessor functions.\r\n *\r\n * When you have tagged a value as both {@link forceDynamicConversion} and blocked force will take precedence.\r\n *\r\n * If `value` is falsy (null / undefined / 0 / empty string etc) it will not be tagged and\r\n * if there is an exception adding the property to the value (because its frozen etc) the\r\n * exception will be swallowed.\r\n * @param value - The object that should be tagged and converted if included into a dynamic\r\n * configuration.\r\n * @returns The original value\r\n */\r\nexport function forceDynamicConversion(value) {\r\n    if (value) {\r\n        try {\r\n            value[FORCE_DYNAMIC] = true;\r\n        }\r\n        catch (e) {\r\n            // Don't throw for this case as it's an ask only\r\n        }\r\n    }\r\n    return value;\r\n}\r\n/**\r\n * @internal\r\n * @ignore\r\n * Helper function to check whether an object can or should be converted into a dynamic\r\n * object.\r\n * @param value - The object to check whether it should be converted\r\n * @returns `true` if the value should be converted otherwise `false`.\r\n */\r\nexport function _canMakeDynamic(getFunc, state, value) {\r\n    var result = false;\r\n    // Object must exist and be truthy\r\n    if (value && !getFunc[state.blkVal]) {\r\n        // Tagged as always convert\r\n        result = value[FORCE_DYNAMIC];\r\n        // Check that it's not explicitly tagged as blocked\r\n        if (!result && !value[BLOCK_DYNAMIC]) {\r\n            // Only convert plain objects or arrays by default\r\n            result = isPlainObject(value) || isArray(value);\r\n        }\r\n    }\r\n    return result;\r\n}\r\n/**\r\n * Throws an invalid access exception\r\n * @param message - The message to include in the exception\r\n */\r\nexport function throwInvalidAccess(message) {\r\n    throwTypeError(\"InvalidAccess:\" + message);\r\n}\r\n//# sourceMappingURL=DynamicSupport.js.map","// Copyright (c) Microsoft Corporation. All rights reserved.\r\n// Licensed under the MIT License.\r\nimport { arrForEach, arrIndexOf, dumpObj, isArray, objDefine, objDefineProp, objForEachKey, objGetOwnPropertyDescriptor } from \"@nevware21/ts-utils\";\r\nimport { UNDEFINED_VALUE } from \"../JavaScriptSDK/InternalConstants\";\r\nimport { _DYN_APPLY, _DYN_HDLR, _DYN_LOGGER, _DYN_PUSH, _DYN_SPLICE, _DYN_THROW_INTERNAL } from \"../__DynamicConstants\";\r\nimport { CFG_HANDLER_LINK, _canMakeDynamic, blockDynamicConversion, throwInvalidAccess } from \"./DynamicSupport\";\r\nvar arrayMethodsToPatch = [\r\n    \"push\",\r\n    \"pop\",\r\n    \"shift\",\r\n    \"unshift\",\r\n    \"splice\"\r\n];\r\nexport var _throwDynamicError = function (logger, name, desc, e) {\r\n    logger && logger[_DYN_THROW_INTERNAL /* @min:%2ethrowInternal */](3 /* eLoggingSeverity.DEBUG */, 108 /* _eInternalMessageId.DynamicConfigException */, \"\".concat(desc, \" [\").concat(name, \"] failed - \") + dumpObj(e));\r\n};\r\nfunction _patchArray(state, target, name) {\r\n    if (isArray(target)) {\r\n        // Monkey Patch the methods that might change the array\r\n        arrForEach(arrayMethodsToPatch, function (method) {\r\n            var orgMethod = target[method];\r\n            target[method] = function () {\r\n                var args = [];\r\n                for (var _i = 0; _i < arguments.length; _i++) {\r\n                    args[_i] = arguments[_i];\r\n                }\r\n                var result = orgMethod[_DYN_APPLY /* @min:%2eapply */](this, args);\r\n                // items may be added, removed or moved so need to make some new dynamic properties\r\n                _makeDynamicObject(state, target, name, \"Patching\");\r\n                return result;\r\n            };\r\n        });\r\n    }\r\n}\r\nfunction _getOwnPropGetter(target, name) {\r\n    var propDesc = objGetOwnPropertyDescriptor(target, name);\r\n    return propDesc && propDesc.get;\r\n}\r\nfunction _createDynamicProperty(state, theConfig, name, value) {\r\n    // Does not appear to be dynamic so lets make it so\r\n    var detail = {\r\n        n: name,\r\n        h: [],\r\n        trk: function (handler) {\r\n            if (handler && handler.fn) {\r\n                if (arrIndexOf(detail.h, handler) === -1) {\r\n                    // Add this handler to the collection that should be notified when the value changes\r\n                    detail.h[_DYN_PUSH /* @min:%2epush */](handler);\r\n                }\r\n                state.trk(handler, detail);\r\n            }\r\n        },\r\n        clr: function (handler) {\r\n            var idx = arrIndexOf(detail.h, handler);\r\n            if (idx !== -1) {\r\n                detail.h[_DYN_SPLICE /* @min:%2esplice */](idx, 1);\r\n            }\r\n        }\r\n    };\r\n    // Flag to optimize lookup response time by avoiding additional function calls\r\n    var checkDynamic = true;\r\n    var isObjectOrArray = false;\r\n    function _getProperty() {\r\n        if (checkDynamic) {\r\n            isObjectOrArray = isObjectOrArray || _canMakeDynamic(_getProperty, state, value);\r\n            // Make sure that if it's an object that we make it dynamic\r\n            if (value && !value[CFG_HANDLER_LINK] && isObjectOrArray) {\r\n                // It doesn't look like it's already dynamic so lets make sure it's converted the object into a dynamic Config as well\r\n                value = _makeDynamicObject(state, value, name, \"Converting\");\r\n            }\r\n            // If it needed to be converted it now has been\r\n            checkDynamic = false;\r\n        }\r\n        // If there is an active handler then add it to the tracking set of handlers\r\n        var activeHandler = state.act;\r\n        if (activeHandler) {\r\n            detail.trk(activeHandler);\r\n        }\r\n        return value;\r\n    }\r\n    // Tag this getter as our dynamic property and provide shortcut for notifying a change\r\n    _getProperty[state.prop] = {\r\n        chng: function () {\r\n            state.add(detail);\r\n        }\r\n    };\r\n    function _setProperty(newValue) {\r\n        if (value !== newValue) {\r\n            if (!!_getProperty[state.ro] && !state.upd) {\r\n                // field is marked as readonly so return false\r\n                throwInvalidAccess(\"[\" + name + \"] is read-only:\" + dumpObj(theConfig));\r\n            }\r\n            if (checkDynamic) {\r\n                isObjectOrArray = isObjectOrArray || _canMakeDynamic(_getProperty, state, value);\r\n                checkDynamic = false;\r\n            }\r\n            // The value must be a plain object or an array to enforce the reference (in-place updates)\r\n            var isReferenced = isObjectOrArray && _getProperty[state.rf];\r\n            if (isObjectOrArray) {\r\n                // We are about to replace a plain object or an array\r\n                if (isReferenced) {\r\n                    // Reassign the properties from the current value to the same properties from the newValue\r\n                    // This will set properties not in the newValue to undefined\r\n                    objForEachKey(value, function (key) {\r\n                        value[key] = newValue ? newValue[key] : UNDEFINED_VALUE;\r\n                    });\r\n                    // Now assign / re-assign value with all of the keys from newValue\r\n                    try {\r\n                        objForEachKey(newValue, function (key, theValue) {\r\n                            _setDynamicProperty(state, value, key, theValue);\r\n                        });\r\n                        // Now drop newValue so when we assign value later it keeps the existing reference\r\n                        newValue = value;\r\n                    }\r\n                    catch (e) {\r\n                        // Unable to convert to dynamic property so just leave as non-dynamic\r\n                        _throwDynamicError((state.hdlr || {})[_DYN_LOGGER /* @min:%2elogger */], name, \"Assigning\", e);\r\n                        // Mark as not an object or array so we don't try and do this again\r\n                        isObjectOrArray = false;\r\n                    }\r\n                }\r\n                else if (value && value[CFG_HANDLER_LINK]) {\r\n                    // As we are replacing the value, if it's already dynamic then we need to notify the listeners\r\n                    // for every property it has already\r\n                    objForEachKey(value, function (key) {\r\n                        // Check if the value is dynamic\r\n                        var getter = _getOwnPropGetter(value, key);\r\n                        if (getter) {\r\n                            // And if it is tell it's listeners that the value has changed\r\n                            var valueState = getter[state.prop];\r\n                            valueState && valueState.chng();\r\n                        }\r\n                    });\r\n                }\r\n            }\r\n            if (newValue !== value) {\r\n                var newIsObjectOrArray = newValue && _canMakeDynamic(_getProperty, state, newValue);\r\n                if (!isReferenced && newIsObjectOrArray) {\r\n                    // As the newValue is an object/array lets preemptively make it dynamic\r\n                    newValue = _makeDynamicObject(state, newValue, name, \"Converting\");\r\n                }\r\n                // Now assign the internal \"value\" to the newValue\r\n                value = newValue;\r\n                isObjectOrArray = newIsObjectOrArray;\r\n            }\r\n            // Cause any listeners to be scheduled for notification\r\n            state.add(detail);\r\n        }\r\n    }\r\n    objDefine(theConfig, detail.n, { g: _getProperty, s: _setProperty });\r\n}\r\nexport function _setDynamicProperty(state, target, name, value) {\r\n    if (target) {\r\n        // To be a dynamic property it needs to have a get function\r\n        var getter = _getOwnPropGetter(target, name);\r\n        var isDynamic = getter && !!getter[state.prop];\r\n        if (!isDynamic) {\r\n            _createDynamicProperty(state, target, name, value);\r\n        }\r\n        else {\r\n            // Looks like it's already dynamic just assign the new value\r\n            target[name] = value;\r\n        }\r\n    }\r\n    return target;\r\n}\r\nexport function _setDynamicPropertyState(state, target, name, flags) {\r\n    if (target) {\r\n        // To be a dynamic property it needs to have a get function\r\n        var getter = _getOwnPropGetter(target, name);\r\n        var isDynamic = getter && !!getter[state.prop];\r\n        var inPlace = flags && flags[0 /* _eSetDynamicPropertyFlags.inPlace */];\r\n        var rdOnly = flags && flags[1 /* _eSetDynamicPropertyFlags.readOnly */];\r\n        var blkProp = flags && flags[2 /* _eSetDynamicPropertyFlags.blockDynamicProperty */];\r\n        if (!isDynamic) {\r\n            if (blkProp) {\r\n                try {\r\n                    // Attempt to mark the target as blocked from conversion\r\n                    blockDynamicConversion(target);\r\n                }\r\n                catch (e) {\r\n                    _throwDynamicError((state.hdlr || {})[_DYN_LOGGER /* @min:%2elogger */], name, \"Blocking\", e);\r\n                }\r\n            }\r\n            try {\r\n                // Make sure it's dynamic so that we can tag the property as per the state\r\n                _setDynamicProperty(state, target, name, target[name]);\r\n                getter = _getOwnPropGetter(target, name);\r\n            }\r\n            catch (e) {\r\n                // Unable to convert to dynamic property so just leave as non-dynamic\r\n                _throwDynamicError((state.hdlr || {})[_DYN_LOGGER /* @min:%2elogger */], name, \"State\", e);\r\n            }\r\n        }\r\n        // Assign the optional flags if true\r\n        if (inPlace) {\r\n            getter[state.rf] = inPlace;\r\n        }\r\n        if (rdOnly) {\r\n            getter[state.ro] = rdOnly;\r\n        }\r\n        if (blkProp) {\r\n            getter[state.blkVal] = true;\r\n        }\r\n    }\r\n    return target;\r\n}\r\nexport function _makeDynamicObject(state, target, name, desc) {\r\n    try {\r\n        // Assign target with new value properties (converting into dynamic properties in the process)\r\n        objForEachKey(target, function (key, value) {\r\n            // Assign and/or make the property dynamic\r\n            _setDynamicProperty(state, target, key, value);\r\n        });\r\n        if (!target[CFG_HANDLER_LINK]) {\r\n            // Link the config back to the dynamic config details\r\n            objDefineProp(target, CFG_HANDLER_LINK, {\r\n                get: function () {\r\n                    return state[_DYN_HDLR /* @min:%2ehdlr */];\r\n                }\r\n            });\r\n            _patchArray(state, target, name);\r\n        }\r\n    }\r\n    catch (e) {\r\n        // Unable to convert to dynamic property so just leave as non-dynamic\r\n        _throwDynamicError((state.hdlr || {})[_DYN_LOGGER /* @min:%2elogger */], name, desc, e);\r\n    }\r\n    return target;\r\n}\r\n//# sourceMappingURL=DynamicProperty.js.map","// Copyright (c) Microsoft Corporation. All rights reserved.\r\n// Licensed under the MIT License.\r\nimport { arrForEach, createCustomError, dumpObj } from \"@nevware21/ts-utils\";\r\nimport { _DYN_LENGTH } from \"../__DynamicConstants\";\r\nvar aggregationErrorType;\r\n/**\r\n * Throws an Aggregation Error which includes all of the errors that led to this error occurring\r\n * @param message - The message describing the aggregation error (the sourceError details are added to this)\r\n * @param sourceErrors - An array of the errors that caused this situation\r\n */\r\nexport function throwAggregationError(message, sourceErrors) {\r\n    if (!aggregationErrorType) {\r\n        aggregationErrorType = createCustomError(\"AggregationError\", function (self, args) {\r\n            if (args[_DYN_LENGTH /* @min:%2elength */] > 1) {\r\n                // Save the provided errors\r\n                self.errors = args[1];\r\n            }\r\n        });\r\n    }\r\n    var theMessage = message || \"One or more errors occurred.\";\r\n    arrForEach(sourceErrors, function (srcError, idx) {\r\n        theMessage += \"\\n\".concat(idx, \" > \").concat(dumpObj(srcError));\r\n    });\r\n    throw new aggregationErrorType(theMessage, sourceErrors || []);\r\n}\r\n//# sourceMappingURL=AggregationError.js.map","// Copyright (c) Microsoft Corporation. All rights reserved.\r\n// Licensed under the MIT License.\r\nimport { arrForEach, arrIndexOf, dumpObj, newSymbol, scheduleTimeout } from \"@nevware21/ts-utils\";\r\nimport { throwAggregationError } from \"../JavaScriptSDK/AggregationError\";\r\nimport { _DYN_BLK_VAL, _DYN_CANCEL, _DYN_HDLR, _DYN_LENGTH, _DYN_LOGGER, _DYN_NOTIFY, _DYN_PUSH, _DYN_RD_ONLY, _DYN_SET_DF, _DYN_THROW_INTERNAL } from \"../__DynamicConstants\";\r\nvar symPrefix = \"[[ai_\";\r\nvar symPostfix = \"]]\";\r\nexport function _createState(cfgHandler) {\r\n    var _a;\r\n    var dynamicPropertySymbol = newSymbol(symPrefix + \"get\" + cfgHandler.uid + symPostfix);\r\n    var dynamicPropertyReadOnly = newSymbol(symPrefix + \"ro\" + cfgHandler.uid + symPostfix);\r\n    var dynamicPropertyReferenced = newSymbol(symPrefix + \"rf\" + cfgHandler.uid + symPostfix);\r\n    var dynamicPropertyBlockValue = newSymbol(symPrefix + \"blkVal\" + cfgHandler.uid + symPostfix);\r\n    var dynamicPropertyDetail = newSymbol(symPrefix + \"dtl\" + cfgHandler.uid + symPostfix);\r\n    var _waitingHandlers = null;\r\n    var _watcherTimer = null;\r\n    var theState;\r\n    function _useHandler(activeHandler, callback) {\r\n        var prevWatcher = theState.act;\r\n        try {\r\n            theState.act = activeHandler;\r\n            if (activeHandler && activeHandler[dynamicPropertyDetail]) {\r\n                // Clear out the previously tracked details for this handler, so that access are re-evaluated\r\n                arrForEach(activeHandler[dynamicPropertyDetail], function (detail) {\r\n                    detail.clr(activeHandler);\r\n                });\r\n                activeHandler[dynamicPropertyDetail] = [];\r\n            }\r\n            callback({\r\n                cfg: cfgHandler.cfg,\r\n                set: cfgHandler.set.bind(cfgHandler),\r\n                setDf: cfgHandler[_DYN_SET_DF /* @min:%2esetDf */].bind(cfgHandler),\r\n                ref: cfgHandler.ref.bind(cfgHandler),\r\n                rdOnly: cfgHandler[_DYN_RD_ONLY /* @min:%2erdOnly */].bind(cfgHandler)\r\n            });\r\n        }\r\n        catch (e) {\r\n            var logger = cfgHandler[_DYN_LOGGER /* @min:%2elogger */];\r\n            if (logger) {\r\n                // Don't let one individual failure break everyone\r\n                logger[_DYN_THROW_INTERNAL /* @min:%2ethrowInternal */](1 /* eLoggingSeverity.CRITICAL */, 107 /* _eInternalMessageId.ConfigWatcherException */, dumpObj(e));\r\n            }\r\n            // Re-throw the exception so that any true \"error\" is reported back to the called\r\n            throw e;\r\n        }\r\n        finally {\r\n            theState.act = prevWatcher || null;\r\n        }\r\n    }\r\n    function _notifyWatchers() {\r\n        if (_waitingHandlers) {\r\n            var notifyHandlers = _waitingHandlers;\r\n            _waitingHandlers = null;\r\n            // Stop any timer as we are running them now anyway\r\n            _watcherTimer && _watcherTimer[_DYN_CANCEL /* @min:%2ecancel */]();\r\n            _watcherTimer = null;\r\n            var watcherFailures_1 = [];\r\n            // Now run the handlers\r\n            arrForEach(notifyHandlers, function (handler) {\r\n                if (handler) {\r\n                    if (handler[dynamicPropertyDetail]) {\r\n                        arrForEach(handler[dynamicPropertyDetail], function (detail) {\r\n                            // Clear out this handler from  previously tracked details, so that access are re-evaluated\r\n                            detail.clr(handler);\r\n                        });\r\n                        handler[dynamicPropertyDetail] = null;\r\n                    }\r\n                    // The handler may have self removed as part of another handler so re-check\r\n                    if (handler.fn) {\r\n                        try {\r\n                            _useHandler(handler, handler.fn);\r\n                        }\r\n                        catch (e) {\r\n                            // Don't let a single failing watcher cause other watches to fail\r\n                            watcherFailures_1[_DYN_PUSH /* @min:%2epush */](e);\r\n                        }\r\n                    }\r\n                }\r\n            });\r\n            // During notification we may have had additional updates -- so notify those updates as well\r\n            if (_waitingHandlers) {\r\n                try {\r\n                    _notifyWatchers();\r\n                }\r\n                catch (e) {\r\n                    watcherFailures_1[_DYN_PUSH /* @min:%2epush */](e);\r\n                }\r\n            }\r\n            if (watcherFailures_1[_DYN_LENGTH /* @min:%2elength */] > 0) {\r\n                throwAggregationError(\"Watcher error(s): \", watcherFailures_1);\r\n            }\r\n        }\r\n    }\r\n    function _addWatcher(detail) {\r\n        if (detail && detail.h[_DYN_LENGTH /* @min:%2elength */] > 0) {\r\n            if (!_waitingHandlers) {\r\n                _waitingHandlers = [];\r\n            }\r\n            if (!_watcherTimer) {\r\n                _watcherTimer = scheduleTimeout(function () {\r\n                    _watcherTimer = null;\r\n                    _notifyWatchers();\r\n                }, 0);\r\n            }\r\n            // Add all of the handlers for this detail (if not already present) - using normal for-loop for performance\r\n            for (var idx = 0; idx < detail.h[_DYN_LENGTH /* @min:%2elength */]; idx++) {\r\n                var handler = detail.h[idx];\r\n                // Add this handler to the collection of handlers to re-execute\r\n                if (handler && arrIndexOf(_waitingHandlers, handler) === -1) {\r\n                    _waitingHandlers[_DYN_PUSH /* @min:%2epush */](handler);\r\n                }\r\n            }\r\n        }\r\n    }\r\n    function _trackHandler(handler, detail) {\r\n        if (handler) {\r\n            var details = handler[dynamicPropertyDetail] = handler[dynamicPropertyDetail] || [];\r\n            if (arrIndexOf(details, detail) === -1) {\r\n                // If this detail is not already listed as tracked then add it so that we re-evaluate it's usage\r\n                details[_DYN_PUSH /* @min:%2epush */](detail);\r\n            }\r\n        }\r\n    }\r\n    theState = (_a = {\r\n            prop: dynamicPropertySymbol,\r\n            ro: dynamicPropertyReadOnly,\r\n            rf: dynamicPropertyReferenced\r\n        },\r\n        _a[_DYN_BLK_VAL /* @min:blkVal */] = dynamicPropertyBlockValue,\r\n        _a[_DYN_HDLR /* @min:hdlr */] = cfgHandler,\r\n        _a.add = _addWatcher,\r\n        _a[_DYN_NOTIFY /* @min:notify */] = _notifyWatchers,\r\n        _a.use = _useHandler,\r\n        _a.trk = _trackHandler,\r\n        _a);\r\n    return theState;\r\n}\r\n//# sourceMappingURL=DynamicState.js.map","// Copyright (c) Microsoft Corporation. All rights reserved.\r\n// Licensed under the MIT License.\r\nimport { dumpObj, isUndefined, objDefine, objForEachKey } from \"@nevware21/ts-utils\";\r\nimport { createUniqueNamespace } from \"../JavaScriptSDK/DataCacheHelper\";\r\nimport { STR_NOT_DYNAMIC_ERROR } from \"../JavaScriptSDK/InternalConstants\";\r\nimport { _DYN_BLK_VAL, _DYN_LOGGER, _DYN_NOTIFY, _DYN_RD_ONLY, _DYN_SET_DF, _DYN_THROW_INTERNAL, _DYN_WARN_TO_CONSOLE, _DYN_WATCH } from \"../__DynamicConstants\";\r\nimport { _applyDefaultValue } from \"./ConfigDefaults\";\r\nimport { _makeDynamicObject, _setDynamicProperty, _setDynamicPropertyState, _throwDynamicError } from \"./DynamicProperty\";\r\nimport { _createState } from \"./DynamicState\";\r\nimport { CFG_HANDLER_LINK, _cfgDeepCopy, getDynamicConfigHandler, throwInvalidAccess } from \"./DynamicSupport\";\r\n/**\r\n * Identifies a function which will be re-called whenever any of it's accessed configuration values\r\n * change.\r\n * @param configHandler - The callback that will be called for the initial request and then whenever any\r\n * accessed configuration changes are identified.\r\n */\r\nfunction _createAndUseHandler(state, configHandler) {\r\n    var handler = {\r\n        fn: configHandler,\r\n        rm: function () {\r\n            // Clear all references to the handler so it can be garbage collected\r\n            // This will also cause this handler to never get called and eventually removed\r\n            handler.fn = null;\r\n            state = null;\r\n            configHandler = null;\r\n        }\r\n    };\r\n    state.use(handler, configHandler);\r\n    return handler;\r\n}\r\n/**\r\n * Creates the dynamic config handler and associates with the target config as the root object\r\n * @param target - The config that you want to be root of the dynamic config\r\n * @param inPlace - Should the passed config be converted in-place or a new proxy returned\r\n * @returns The existing dynamic handler or a new instance with the provided config values\r\n */\r\nfunction _createDynamicHandler(logger, target, inPlace) {\r\n    var _a;\r\n    var dynamicHandler = getDynamicConfigHandler(target);\r\n    if (dynamicHandler) {\r\n        // The passed config is already dynamic so return it's tracker\r\n        return dynamicHandler;\r\n    }\r\n    var uid = createUniqueNamespace(\"dyncfg\", true);\r\n    var newTarget = (target && inPlace !== false) ? target : _cfgDeepCopy(target);\r\n    var theState;\r\n    function _notifyWatchers() {\r\n        theState[_DYN_NOTIFY /* @min:%2enotify */]();\r\n    }\r\n    function _setValue(target, name, value) {\r\n        try {\r\n            target = _setDynamicProperty(theState, target, name, value);\r\n        }\r\n        catch (e) {\r\n            // Unable to convert to dynamic property so just leave as non-dynamic\r\n            _throwDynamicError(logger, name, \"Setting value\", e);\r\n        }\r\n        return target[name];\r\n    }\r\n    function _watch(configHandler) {\r\n        return _createAndUseHandler(theState, configHandler);\r\n    }\r\n    function _block(configHandler, allowUpdate) {\r\n        theState.use(null, function (details) {\r\n            var prevUpd = theState.upd;\r\n            try {\r\n                if (!isUndefined(allowUpdate)) {\r\n                    theState.upd = allowUpdate;\r\n                }\r\n                configHandler(details);\r\n            }\r\n            finally {\r\n                theState.upd = prevUpd;\r\n            }\r\n        });\r\n    }\r\n    function _ref(target, name) {\r\n        var _a;\r\n        // Make sure it's dynamic and mark as referenced with it's current value\r\n        return _setDynamicPropertyState(theState, target, name, (_a = {}, _a[0 /* _eSetDynamicPropertyFlags.inPlace */] = true, _a))[name];\r\n    }\r\n    function _rdOnly(target, name) {\r\n        var _a;\r\n        // Make sure it's dynamic and mark as readonly with it's current value\r\n        return _setDynamicPropertyState(theState, target, name, (_a = {}, _a[1 /* _eSetDynamicPropertyFlags.readOnly */] = true, _a))[name];\r\n    }\r\n    function _blkPropValue(target, name) {\r\n        var _a;\r\n        // Make sure it's dynamic and mark as readonly with it's current value\r\n        return _setDynamicPropertyState(theState, target, name, (_a = {}, _a[2 /* _eSetDynamicPropertyFlags.blockDynamicProperty */] = true, _a))[name];\r\n    }\r\n    function _applyDefaults(theConfig, defaultValues) {\r\n        if (defaultValues) {\r\n            // Resolve/apply the defaults\r\n            objForEachKey(defaultValues, function (name, value) {\r\n                // Sets the value and makes it dynamic (if it doesn't already exist)\r\n                _applyDefaultValue(cfgHandler, theConfig, name, value);\r\n            });\r\n        }\r\n        return theConfig;\r\n    }\r\n    var cfgHandler = (_a = {\r\n            uid: null,\r\n            cfg: newTarget\r\n        },\r\n        _a[_DYN_LOGGER /* @min:logger */] = logger,\r\n        _a[_DYN_NOTIFY /* @min:notify */] = _notifyWatchers,\r\n        _a.set = _setValue,\r\n        _a[_DYN_SET_DF /* @min:setDf */] = _applyDefaults,\r\n        _a[_DYN_WATCH /* @min:watch */] = _watch,\r\n        _a.ref = _ref,\r\n        _a[_DYN_RD_ONLY /* @min:rdOnly */] = _rdOnly,\r\n        _a[_DYN_BLK_VAL /* @min:blkVal */] = _blkPropValue,\r\n        _a._block = _block,\r\n        _a);\r\n    objDefine(cfgHandler, \"uid\", {\r\n        c: false,\r\n        e: false,\r\n        w: false,\r\n        v: uid\r\n    });\r\n    theState = _createState(cfgHandler);\r\n    // Setup tracking for all defined default keys\r\n    _makeDynamicObject(theState, newTarget, \"config\", \"Creating\");\r\n    return cfgHandler;\r\n}\r\n/**\r\n * Log an invalid access message to the console\r\n * @param message\r\n */\r\nfunction _logInvalidAccess(logger, message) {\r\n    if (logger) {\r\n        logger[_DYN_WARN_TO_CONSOLE /* @min:%2ewarnToConsole */](message);\r\n        logger[_DYN_THROW_INTERNAL /* @min:%2ethrowInternal */](2 /* eLoggingSeverity.WARNING */, 108 /* _eInternalMessageId.DynamicConfigException */, message);\r\n    }\r\n    else {\r\n        // We don't have a logger so just throw an exception\r\n        throwInvalidAccess(message);\r\n    }\r\n}\r\n/**\r\n * Create or return a dynamic version of the passed config, if it is not already dynamic\r\n * @param config - The config to be converted into a dynamic config\r\n * @param defaultConfig - The default values to apply on the config if the properties don't already exist\r\n * @param inPlace - Should the config be converted in-place into a dynamic config or a new instance returned, defaults to true\r\n * @returns The dynamic config handler for the config (whether new or existing)\r\n */\r\nexport function createDynamicConfig(config, defaultConfig, logger, inPlace) {\r\n    var dynamicHandler = _createDynamicHandler(logger, config || {}, inPlace);\r\n    if (defaultConfig) {\r\n        dynamicHandler[_DYN_SET_DF /* @min:%2esetDf */](dynamicHandler.cfg, defaultConfig);\r\n    }\r\n    return dynamicHandler;\r\n}\r\n/**\r\n * Watch and track changes for accesses to the current config, the provided config MUST already be\r\n * a dynamic config or a child accessed via the dynamic config\r\n * @param config\r\n * @param configHandler\r\n * @param logger - The logger instance to use if there is no existing handler\r\n * @returns A watcher handler instance that can be used to remove itself when being unloaded\r\n * @throws TypeError if the provided config is not a dynamic config instance\r\n */\r\nexport function onConfigChange(config, configHandler, logger) {\r\n    var handler = config[CFG_HANDLER_LINK] || config;\r\n    if (handler.cfg && (handler.cfg === config || handler.cfg[CFG_HANDLER_LINK] === handler)) {\r\n        return handler[_DYN_WATCH /* @min:%2ewatch */](configHandler);\r\n    }\r\n    _logInvalidAccess(logger, STR_NOT_DYNAMIC_ERROR + dumpObj(config));\r\n    return createDynamicConfig(config, null, logger)[_DYN_WATCH /* @min:%2ewatch */](configHandler);\r\n}\r\n//# sourceMappingURL=DynamicConfig.js.map","// Copyright (c) Microsoft Corporation. All rights reserved.\r\n// Licensed under the MIT License.\r\n\r\nimport { getGlobal, objAssign, objCreate, objDefineProp, objHasOwnProperty, throwTypeError } from \"@nevware21/ts-utils\";\r\nimport {\r\n    ObjClass, ObjProto,\r\n    strDefault, strShimFunction, strShimPrototype\r\n} from \"./Constants\";\r\n\r\n// Most of these functions have been directly shamelessly \"lifted\" from the https://github.com/@microsoft/tslib and\r\n// modified to be ES5 compatible and applying several minification and tree-shaking techniques so that Application Insights\r\n// can successfully use TypeScript \"importHelpers\" which imports tslib during compilation but it will use these at runtime\r\n// Which is also why all of the functions have not been included as Application Insights currently doesn't use or require\r\n// them.\r\n\r\nexport const SymbolObj = (getGlobal()||{})[\"Symbol\"];\r\nexport const ReflectObj = (getGlobal()||{})[\"Reflect\"];\r\nexport const __hasReflect = !!ReflectObj;\r\n\r\nconst strDecorate = \"decorate\";\r\nconst strMetadata = \"metadata\";\r\nconst strGetOwnPropertySymbols = \"getOwnPropertySymbols\";\r\nconst strIterator = \"iterator\";\r\nconst strHasOwnProperty = \"hasOwnProperty\";\r\n\r\nexport declare type ObjAssignFunc = (t: any, ...sources:any[]) => any;\r\n\r\nexport var __objAssignFnImpl: ObjAssignFunc = function(t: any): any {\r\n    // tslint:disable-next-line: ban-comma-operator\r\n    for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n        s = arguments[i];\r\n        for (var p in s) {\r\n            if (ObjProto[strHasOwnProperty].call(s, p)) {\r\n                (t as any)[p] = s[p];\r\n            }\r\n        }\r\n    }\r\n    return t;\r\n};\r\n\r\nexport var __assignFn: ObjAssignFunc = objAssign || __objAssignFnImpl;\r\n\r\n// tslint:disable-next-line: only-arrow-functions\r\nvar extendStaticsFn = function(d: any, b: any): any {\r\n    extendStaticsFn = ObjClass[\"setPrototypeOf\"] ||\r\n        // tslint:disable-next-line: only-arrow-functions\r\n        ({ __proto__: [] } instanceof Array && function (d: any, b: any) {\r\n            d.__proto__ = b;\r\n        }) ||\r\n        // tslint:disable-next-line: only-arrow-functions\r\n        function (d: any, b: any) {\r\n            for (var p in b) {\r\n                if (b[strHasOwnProperty](p)) {\r\n                    d[p] = b[p];\r\n                }\r\n            }\r\n        };\r\n    return extendStaticsFn(d, b);\r\n};\r\n\r\nexport function __extendsFn(d: any, b: any) {\r\n    if (typeof b !== strShimFunction && b !== null) {\r\n        throwTypeError(\"Class extends value \" + String(b) + \" is not a constructor or null\");\r\n    }\r\n    extendStaticsFn(d, b);\r\n    function __(this: any) {\r\n        this.constructor = d;\r\n    }\r\n    // tslint:disable-next-line: ban-comma-operator\r\n    d[strShimPrototype] = b === null ? objCreate(b) : (__[strShimPrototype] = b[strShimPrototype], new (__ as any)());\r\n}\r\n\r\nexport function __restFn(s: any, e: any) {\r\n    var t = {};\r\n    for (var k in s) {\r\n        if (objHasOwnProperty(s, k) && e.indexOf(k) < 0) {\r\n            t[k] = s[k];\r\n        }\r\n    }\r\n    if (s != null && typeof ObjClass[strGetOwnPropertySymbols] === strShimFunction) {\r\n        for (var i = 0, p = ObjClass[strGetOwnPropertySymbols](s); i < p.length; i++) {\r\n            if (e.indexOf(p[i]) < 0 && ObjProto[\"propertyIsEnumerable\"].call(s, p[i])) {\r\n                t[p[i]] = s[p[i]];\r\n            }\r\n        }\r\n    }\r\n    return t;\r\n}\r\n\r\nexport function __decorateFn(decorators: any, target: any, key: any, desc: any) {\r\n    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = ObjClass[\"getOwnPropertyDescriptor\"](target, key) : desc, d;\r\n    if (__hasReflect && typeof ReflectObj[strDecorate] === strShimFunction) {\r\n        r = ReflectObj[strDecorate](decorators, target, key, desc);\r\n    } else {\r\n        for (var i = decorators.length - 1; i >= 0; i--) {\r\n            // eslint-disable-next-line no-cond-assign\r\n            if (d = decorators[i]) {\r\n                r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n            }\r\n        }\r\n    }\r\n\r\n    // tslint:disable-next-line:ban-comma-operator\r\n    return c > 3 && r && objDefineProp(target, key, r), r;\r\n}\r\n\r\nexport function __paramFn(paramIndex: number, decorator: Function) {\r\n    return function (target: any, key: any) {\r\n        decorator(target, key, paramIndex);\r\n    }\r\n}\r\n\r\nexport function __metadataFn(metadataKey: any, metadataValue: any) {\r\n    if (__hasReflect && ReflectObj[strMetadata] === strShimFunction) {\r\n        return ReflectObj[strMetadata](metadataKey, metadataValue);\r\n    }\r\n}\r\n\r\nexport function __exportStarFn(m: any, o: any) {\r\n    for (var p in m) {\r\n        if (p !== strDefault && !objHasOwnProperty(o, p)) {\r\n            __createBindingFn(o, m, p);\r\n        }\r\n    }\r\n}\r\n\r\nexport function __createBindingFn(o: any, m: any, k: any, k2?: any) {\r\n    if (k2 === undefined) {\r\n        k2 = k;\r\n    }\r\n    \r\n    if (!!objDefineProp) {\r\n        objDefineProp(o, k2, {\r\n            enumerable: true,\r\n            get() {\r\n                return m[k];\r\n            }\r\n        });\r\n    } else {\r\n        o[k2] = m[k];\r\n    }\r\n}\r\n\r\nexport function __valuesFn(o: any) {\r\n    var s = typeof SymbolObj === strShimFunction && SymbolObj[strIterator], m = s && o[s], i = 0;\r\n    if (m) {\r\n        return m.call(o);\r\n    }\r\n\r\n    if (o && typeof o.length === \"number\") {\r\n        return {\r\n            next () {\r\n                if (o && i >= o.length) {\r\n                    o = void 0;\r\n                }\r\n                return { value: o && o[i++], done: !o };\r\n            }\r\n        };\r\n    }\r\n\r\n    throwTypeError(s ? \"Object is not iterable.\" : \"Symbol.iterator is not defined.\");\r\n}\r\n\r\nexport function __readFn(o: any, n: any) {\r\n    var m = typeof SymbolObj === strShimFunction && o[SymbolObj[strIterator]];\r\n    if (!m) {\r\n        return o;\r\n    }\r\n\r\n    var i = m.call(o), r, ar = [], e;\r\n    try {\r\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) {\r\n            ar.push(r.value);\r\n        }\r\n    } catch (error) {\r\n        e = {\r\n            error\r\n        };\r\n    } finally {\r\n        try {\r\n            // tslint:disable-next-line:no-conditional-assignment\r\n            if (r && !r.done && (m = i[\"return\"])) {\r\n                m.call(i);\r\n            }\r\n        } finally {\r\n            if (e) {\r\n                // eslint-disable-next-line no-unsafe-finally\r\n                throw e.error;\r\n            }\r\n        }\r\n    }\r\n    return ar;\r\n}\r\n\r\n/** @deprecated */\r\nexport function __spreadArraysFn() {\r\n    var theArgs = arguments;\r\n    // Calculate new total size\r\n    for (var s = 0, i = 0, il = theArgs.length; i < il; i++) {\r\n        s += theArgs[i].length;\r\n    }\r\n\r\n    // Create new full array\r\n    for (var r = Array(s), k = 0, i = 0; i < il; i++) {\r\n        for (var a = theArgs[i], j = 0, jl = a.length; j < jl; j++, k++) {\r\n            r[k] = a[j];\r\n        }\r\n    }\r\n\r\n    return r;\r\n}\r\n\r\nexport function __spreadArrayFn(to: any, from: any) {\r\n    for (var i = 0, il = from.length, j = to.length; i < il; i++, j++) {\r\n        to[j] = from[i];\r\n    }\r\n\r\n    return to;\r\n}\r\n\r\nexport function __makeTemplateObjectFn(cooked: any, raw: any) {\r\n    if (objDefineProp) {\r\n        objDefineProp(cooked, \"raw\", { value: raw });\r\n    } else {\r\n        cooked.raw = raw;\r\n    }\r\n\r\n    return cooked;\r\n}\r\n\r\nexport function __importStarFn(mod: any) {\r\n    if (mod && mod.__esModule) {\r\n        return mod;\r\n    }\r\n\r\n    var result = {};\r\n    if (mod != null) {\r\n        for (var k in mod) {\r\n            if (k !== strDefault && Object.prototype.hasOwnProperty.call(mod, k)) {\r\n                __createBindingFn(result, mod, k);\r\n            }\r\n        }\r\n    }\r\n\r\n    // Set default module\r\n    if (!!objDefineProp) {\r\n        objDefineProp( result, strDefault, { enumerable: true, value: mod });\r\n    } else {\r\n        result[strDefault] = mod;\r\n    }\r\n\r\n    return result;\r\n}\r\n\r\nexport function __importDefaultFn(mod:any) {\r\n    return (mod && mod.__esModule) ? mod : { strDefault: mod };\r\n}\r\n","// Copyright (c) Microsoft Corporation. All rights reserved.\r\n// Licensed under the MIT License.\r\nimport { createPromise, doAwaitResponse } from \"@nevware21/ts-async\";\r\nimport { arrSlice, getLength } from \"@nevware21/ts-utils\";\r\nimport { _DYN_UNLOAD } from \"../__DynamicConstants\";\r\n/**\r\n * Run the unload function of the target object if it exists\r\n * @param target - The target object that contains the unload function\r\n * @param isAsync - The caller identifies whether it is expecting the operation to complete synchronously or asynchronously. Even\r\n * if the caller is not waiting the operation may still be performed asynchronously depending on the component and the reverse is\r\n * also true.\r\n * @returns The result of the target function\r\n */\r\nexport function runTargetUnload(target, isAsync) {\r\n    if (target && target[_DYN_UNLOAD /* @min:%2eunload */]) {\r\n        return target[_DYN_UNLOAD /* @min:%2eunload */](isAsync);\r\n    }\r\n}\r\n/**\r\n * Call the unload function on all targets handling any returned [IPromise](https://nevware21.github.io/ts-async/typedoc/interfaces/IPromise.html)\r\n * / Promise before calling the next targets unload\r\n * @param targets - An array of the targets to unload\r\n * @param isAsync - The caller identifies whether it is expecting the operations to complete synchronously or asynchronously.  Even\r\n * if the caller is not waiting the operation may still be performed asynchronously depending on the component and the reverse is\r\n * also true.\r\n * @param done - Optional callback function to call once all of the unload functions have been called.\r\n */\r\nexport function doUnloadAll(targets, isAsync, done) {\r\n    var result;\r\n    if (!done) {\r\n        result = createPromise(function (resolved) {\r\n            done = resolved;\r\n        });\r\n    }\r\n    if (targets && getLength(targets) > 0) {\r\n        doAwaitResponse(runTargetUnload(targets[0], isAsync), function () {\r\n            doUnloadAll(arrSlice(targets, 1), isAsync, done);\r\n        });\r\n    }\r\n    else {\r\n        done();\r\n    }\r\n    return result;\r\n}\r\n//# sourceMappingURL=AsyncUtils.js.map","// Copyright (c) Microsoft Corporation. All rights reserved.\r\n// Licensed under the MIT License.\r\nexport var ChannelControllerPriority = 500;\r\n//# sourceMappingURL=Constants.js.map","// Copyright (c) Microsoft Corporation. All rights reserved.\r\n// Licensed under the MIT License.\r\nimport { getInst } from \"@nevware21/ts-utils\";\r\nimport { _DYN_APPLY, _DYN_LENGTH } from \"../__DynamicConstants\";\r\nimport { STR_EVENTS_DISCARDED, STR_EVENTS_SEND_REQUEST, STR_EVENTS_SENT, STR_PERF_EVENT } from \"./InternalConstants\";\r\nvar listenerFuncs = [STR_EVENTS_SENT, STR_EVENTS_DISCARDED, STR_EVENTS_SEND_REQUEST, STR_PERF_EVENT];\r\nvar _aiNamespace = null;\r\nvar _debugListener;\r\nfunction _listenerProxyFunc(name, config) {\r\n    return function () {\r\n        var args = arguments;\r\n        var dbgExt = getDebugExt(config);\r\n        if (dbgExt) {\r\n            var listener = dbgExt.listener;\r\n            if (listener && listener[name]) {\r\n                listener[name][_DYN_APPLY /* @min:%2eapply */](listener, args);\r\n            }\r\n        }\r\n    };\r\n}\r\nfunction _getExtensionNamespace() {\r\n    // Cache the lookup of the global namespace object\r\n    var target = getInst(\"Microsoft\");\r\n    if (target) {\r\n        _aiNamespace = target[\"ApplicationInsights\"];\r\n    }\r\n    return _aiNamespace;\r\n}\r\nexport function getDebugExt(config) {\r\n    var ns = _aiNamespace;\r\n    if (!ns && config.disableDbgExt !== true) {\r\n        ns = _aiNamespace || _getExtensionNamespace();\r\n    }\r\n    return ns ? ns[\"ChromeDbgExt\"] : null;\r\n}\r\nexport function getDebugListener(config) {\r\n    if (!_debugListener) {\r\n        _debugListener = {};\r\n        for (var lp = 0; lp < listenerFuncs[_DYN_LENGTH /* @min:%2elength */]; lp++) {\r\n            _debugListener[listenerFuncs[lp]] = _listenerProxyFunc(listenerFuncs[lp], config);\r\n        }\r\n    }\r\n    return _debugListener;\r\n}\r\n//# sourceMappingURL=DbgExtensionUtils.js.map","// Copyright (c) Microsoft Corporation. All rights reserved.\r\n// Licensed under the MIT License.\r\n\"use strict\";\r\nvar _a;\r\nimport dynamicProto from \"@microsoft/dynamicproto-js\";\r\nimport { dumpObj, isFunction, isUndefined } from \"@nevware21/ts-utils\";\r\nimport { createDynamicConfig, onConfigChange } from \"../Config/DynamicConfig\";\r\nimport { _DYN_DIAG_LOG, _DYN_LOGGER, _DYN_LOGGING_LEVEL_CONSOL4, _DYN_LOG_INTERNAL_MESSAGE, _DYN_MESSAGE, _DYN_MESSAGE_ID, _DYN_PUSH, _DYN_REPLACE, _DYN_THROW_INTERNAL, _DYN_UNLOAD, _DYN_WARN_TO_CONSOLE } from \"../__DynamicConstants\";\r\nimport { getDebugExt } from \"./DbgExtensionUtils\";\r\nimport { getConsole, getJSON, hasJSON } from \"./EnvUtils\";\r\nimport { STR_EMPTY } from \"./InternalConstants\";\r\nvar STR_WARN_TO_CONSOLE = \"warnToConsole\";\r\n/**\r\n * For user non actionable traces use AI Internal prefix.\r\n */\r\nvar AiNonUserActionablePrefix = \"AI (Internal): \";\r\n/**\r\n * Prefix of the traces in portal.\r\n */\r\nvar AiUserActionablePrefix = \"AI: \";\r\n/**\r\n *  Session storage key for the prefix for the key indicating message type already logged\r\n */\r\nvar AIInternalMessagePrefix = \"AITR_\";\r\nvar defaultValues = {\r\n    loggingLevelConsole: 0,\r\n    loggingLevelTelemetry: 1,\r\n    maxMessageLimit: 25,\r\n    enableDebug: false\r\n};\r\nvar _logFuncs = (_a = {},\r\n    _a[0 /* eLoggingSeverity.DISABLED */] = null,\r\n    _a[1 /* eLoggingSeverity.CRITICAL */] = \"errorToConsole\",\r\n    _a[2 /* eLoggingSeverity.WARNING */] = STR_WARN_TO_CONSOLE,\r\n    _a[3 /* eLoggingSeverity.DEBUG */] = \"debugToConsole\",\r\n    _a);\r\nfunction _sanitizeDiagnosticText(text) {\r\n    if (text) {\r\n        return \"\\\"\" + text[_DYN_REPLACE /* @min:%2ereplace */](/\\\"/g, STR_EMPTY) + \"\\\"\";\r\n    }\r\n    return STR_EMPTY;\r\n}\r\nfunction _logToConsole(func, message) {\r\n    var theConsole = getConsole();\r\n    if (!!theConsole) {\r\n        var logFunc = \"log\";\r\n        if (theConsole[func]) {\r\n            logFunc = func;\r\n        }\r\n        if (isFunction(theConsole[logFunc])) {\r\n            theConsole[logFunc](message);\r\n        }\r\n    }\r\n}\r\nvar _InternalLogMessage = /** @class */ (function () {\r\n    function _InternalLogMessage(msgId, msg, isUserAct, properties) {\r\n        if (isUserAct === void 0) { isUserAct = false; }\r\n        var _self = this;\r\n        _self[_DYN_MESSAGE_ID /* @min:%2emessageId */] = msgId;\r\n        _self[_DYN_MESSAGE /* @min:%2emessage */] =\r\n            (isUserAct ? AiUserActionablePrefix : AiNonUserActionablePrefix) +\r\n                msgId;\r\n        var strProps = STR_EMPTY;\r\n        if (hasJSON()) {\r\n            strProps = getJSON().stringify(properties);\r\n        }\r\n        var diagnosticText = (msg ? \" message:\" + _sanitizeDiagnosticText(msg) : STR_EMPTY) +\r\n            (properties ? \" props:\" + _sanitizeDiagnosticText(strProps) : STR_EMPTY);\r\n        _self[_DYN_MESSAGE /* @min:%2emessage */] += diagnosticText;\r\n    }\r\n    _InternalLogMessage.dataType = \"MessageData\";\r\n    return _InternalLogMessage;\r\n}());\r\nexport { _InternalLogMessage };\r\nexport function safeGetLogger(core, config) {\r\n    return (core || {})[_DYN_LOGGER /* @min:%2elogger */] || new DiagnosticLogger(config);\r\n}\r\nvar DiagnosticLogger = /** @class */ (function () {\r\n    function DiagnosticLogger(config) {\r\n        this.identifier = \"DiagnosticLogger\";\r\n        /**\r\n         * The internal logging queue\r\n         */\r\n        this.queue = [];\r\n        /**\r\n         * Count of internal messages sent\r\n         */\r\n        var _messageCount = 0;\r\n        /**\r\n         * Holds information about what message types were already logged to console or sent to server.\r\n         */\r\n        var _messageLogged = {};\r\n        var _loggingLevelConsole;\r\n        var _loggingLevelTelemetry;\r\n        var _maxInternalMessageLimit;\r\n        var _enableDebug;\r\n        var _unloadHandler;\r\n        dynamicProto(DiagnosticLogger, this, function (_self) {\r\n            _unloadHandler = _setDefaultsFromConfig(config || {});\r\n            _self.consoleLoggingLevel = function () { return _loggingLevelConsole; };\r\n            /**\r\n             * This method will throw exceptions in debug mode or attempt to log the error as a console warning.\r\n             * @param severity - {LoggingSeverity} - The severity of the log message\r\n             * @param message - {_InternalLogMessage} - The log message.\r\n             */\r\n            _self[_DYN_THROW_INTERNAL /* @min:%2ethrowInternal */] = function (severity, msgId, msg, properties, isUserAct) {\r\n                if (isUserAct === void 0) { isUserAct = false; }\r\n                var message = new _InternalLogMessage(msgId, msg, isUserAct, properties);\r\n                if (_enableDebug) {\r\n                    throw dumpObj(message);\r\n                }\r\n                else {\r\n                    // Get the logging function and fallback to warnToConsole of for some reason errorToConsole doesn't exist\r\n                    var logFunc = _logFuncs[severity] || STR_WARN_TO_CONSOLE;\r\n                    if (!isUndefined(message[_DYN_MESSAGE /* @min:%2emessage */])) {\r\n                        if (isUserAct) {\r\n                            // check if this message type was already logged to console for this page view and if so, don't log it again\r\n                            var messageKey = +message[_DYN_MESSAGE_ID /* @min:%2emessageId */];\r\n                            if (!_messageLogged[messageKey] && _loggingLevelConsole >= severity) {\r\n                                _self[logFunc](message[_DYN_MESSAGE /* @min:%2emessage */]);\r\n                                _messageLogged[messageKey] = true;\r\n                            }\r\n                        }\r\n                        else {\r\n                            // Only log traces if the console Logging Level is >= the throwInternal severity level\r\n                            if (_loggingLevelConsole >= severity) {\r\n                                _self[logFunc](message[_DYN_MESSAGE /* @min:%2emessage */]);\r\n                            }\r\n                        }\r\n                        _logInternalMessage(severity, message);\r\n                    }\r\n                    else {\r\n                        _debugExtMsg(\"throw\" + (severity === 1 /* eLoggingSeverity.CRITICAL */ ? \"Critical\" : \"Warning\"), message);\r\n                    }\r\n                }\r\n            };\r\n            _self.debugToConsole = function (message) {\r\n                _logToConsole(\"debug\", message);\r\n                _debugExtMsg(\"warning\", message);\r\n            };\r\n            _self[_DYN_WARN_TO_CONSOLE /* @min:%2ewarnToConsole */] = function (message) {\r\n                _logToConsole(\"warn\", message);\r\n                _debugExtMsg(\"warning\", message);\r\n            };\r\n            _self.errorToConsole = function (message) {\r\n                _logToConsole(\"error\", message);\r\n                _debugExtMsg(\"error\", message);\r\n            };\r\n            _self.resetInternalMessageCount = function () {\r\n                _messageCount = 0;\r\n                _messageLogged = {};\r\n            };\r\n            _self[_DYN_LOG_INTERNAL_MESSAGE /* @min:%2elogInternalMessage */] = _logInternalMessage;\r\n            _self[_DYN_UNLOAD /* @min:%2eunload */] = function (isAsync) {\r\n                _unloadHandler && _unloadHandler.rm();\r\n                _unloadHandler = null;\r\n            };\r\n            function _logInternalMessage(severity, message) {\r\n                if (_areInternalMessagesThrottled()) {\r\n                    return;\r\n                }\r\n                // check if this message type was already logged for this session and if so, don't log it again\r\n                var logMessage = true;\r\n                var messageKey = AIInternalMessagePrefix + message[_DYN_MESSAGE_ID /* @min:%2emessageId */];\r\n                // if the session storage is not available, limit to only one message type per page view\r\n                if (_messageLogged[messageKey]) {\r\n                    logMessage = false;\r\n                }\r\n                else {\r\n                    _messageLogged[messageKey] = true;\r\n                }\r\n                if (logMessage) {\r\n                    // Push the event in the internal queue\r\n                    if (severity <= _loggingLevelTelemetry) {\r\n                        _self.queue[_DYN_PUSH /* @min:%2epush */](message);\r\n                        _messageCount++;\r\n                        _debugExtMsg((severity === 1 /* eLoggingSeverity.CRITICAL */ ? \"error\" : \"warn\"), message);\r\n                    }\r\n                    // When throttle limit reached, send a special event\r\n                    if (_messageCount === _maxInternalMessageLimit) {\r\n                        var throttleLimitMessage = \"Internal events throttle limit per PageView reached for this app.\";\r\n                        var throttleMessage = new _InternalLogMessage(23 /* _eInternalMessageId.MessageLimitPerPVExceeded */, throttleLimitMessage, false);\r\n                        _self.queue[_DYN_PUSH /* @min:%2epush */](throttleMessage);\r\n                        if (severity === 1 /* eLoggingSeverity.CRITICAL */) {\r\n                            _self.errorToConsole(throttleLimitMessage);\r\n                        }\r\n                        else {\r\n                            _self[_DYN_WARN_TO_CONSOLE /* @min:%2ewarnToConsole */](throttleLimitMessage);\r\n                        }\r\n                    }\r\n                }\r\n            }\r\n            function _setDefaultsFromConfig(config) {\r\n                // make sure the config is dynamic\r\n                return onConfigChange(createDynamicConfig(config, defaultValues, _self).cfg, function (details) {\r\n                    var config = details.cfg;\r\n                    _loggingLevelConsole = config[_DYN_LOGGING_LEVEL_CONSOL4 /* @min:%2eloggingLevelConsole */];\r\n                    _loggingLevelTelemetry = config.loggingLevelTelemetry;\r\n                    _maxInternalMessageLimit = config.maxMessageLimit;\r\n                    _enableDebug = config.enableDebug;\r\n                });\r\n            }\r\n            function _areInternalMessagesThrottled() {\r\n                return _messageCount >= _maxInternalMessageLimit;\r\n            }\r\n            function _debugExtMsg(name, data) {\r\n                var dbgExt = getDebugExt(config || {});\r\n                if (dbgExt && dbgExt[_DYN_DIAG_LOG /* @min:%2ediagLog */]) {\r\n                    dbgExt[_DYN_DIAG_LOG /* @min:%2ediagLog */](name, data);\r\n                }\r\n            }\r\n        });\r\n    }\r\n    /**\r\n     * 0: OFF (default)\r\n     * 1: CRITICAL\r\n     * 2: >= WARNING\r\n     */\r\n    DiagnosticLogger.prototype.consoleLoggingLevel = function () {\r\n        // @DynamicProtoStub -- DO NOT add any code as this will be removed during packaging\r\n        return 0;\r\n    };\r\n    /**\r\n     * This method will throw exceptions in debug mode or attempt to log the error as a console warning.\r\n     * @param severity - {LoggingSeverity} - The severity of the log message\r\n     * @param message - {_InternalLogMessage} - The log message.\r\n     */\r\n    DiagnosticLogger.prototype.throwInternal = function (severity, msgId, msg, properties, isUserAct) {\r\n        if (isUserAct === void 0) { isUserAct = false; }\r\n        // @DynamicProtoStub -- DO NOT add any code as this will be removed during packaging\r\n    };\r\n    /**\r\n     * This will write a debug message to the console if possible\r\n     * @param message - {string} - The debug message\r\n     */\r\n    DiagnosticLogger.prototype.debugToConsole = function (message) {\r\n        // @DynamicProtoStub -- DO NOT add any code as this will be removed during packaging\r\n    };\r\n    /**\r\n     * This will write a warning to the console if possible\r\n     * @param message - {string} - The warning message\r\n     */\r\n    DiagnosticLogger.prototype.warnToConsole = function (message) {\r\n        // @DynamicProtoStub -- DO NOT add any code as this will be removed during packaging\r\n    };\r\n    /**\r\n     * This will write an error to the console if possible\r\n     * @param message - {string} - The warning message\r\n     */\r\n    DiagnosticLogger.prototype.errorToConsole = function (message) {\r\n        // @DynamicProtoStub -- DO NOT add any code as this will be removed during packaging\r\n    };\r\n    /**\r\n     * Resets the internal message count\r\n     */\r\n    DiagnosticLogger.prototype.resetInternalMessageCount = function () {\r\n        // @DynamicProtoStub -- DO NOT add any code as this will be removed during packaging\r\n    };\r\n    /**\r\n     * Logs a message to the internal queue.\r\n     * @param severity - {LoggingSeverity} - The severity of the log message\r\n     * @param message - {_InternalLogMessage} - The message to log.\r\n     */\r\n    DiagnosticLogger.prototype.logInternalMessage = function (severity, message) {\r\n        // @DynamicProtoStub -- DO NOT add any code as this will be removed during packaging\r\n    };\r\n    /**\r\n     * Unload and remove any state that this IDiagnosticLogger may be holding, this is generally called when the\r\n     * owning SDK is being unloaded.\r\n     * @param isAsync - Can the unload be performed asynchronously (default)\r\n     * @return If the unload occurs synchronously then nothing should be returned, if happening asynchronously then\r\n     * the function should return an [IPromise](https://nevware21.github.io/ts-async/typedoc/interfaces/IPromise.html)\r\n     * / Promise to allow any listeners to wait for the operation to complete.\r\n     */\r\n    DiagnosticLogger.prototype.unload = function (isAsync) {\r\n        // @DynamicProtoStub -- DO NOT add any code as this will be removed during packaging\r\n    };\r\n    return DiagnosticLogger;\r\n}());\r\nexport { DiagnosticLogger };\r\nfunction _getLogger(logger) {\r\n    return (logger || new DiagnosticLogger());\r\n}\r\n/**\r\n * This is a helper method which will call throwInternal on the passed logger, will throw exceptions in\r\n * debug mode or attempt to log the error as a console warning. This helper is provided mostly to better\r\n * support minification as logger.throwInternal() will not compress the publish \"throwInternal\" used throughout\r\n * the code.\r\n * @param logger - The Diagnostic Logger instance to use.\r\n * @param severity - {LoggingSeverity} - The severity of the log message\r\n * @param message - {_InternalLogMessage} - The log message.\r\n */\r\nexport function _throwInternal(logger, severity, msgId, msg, properties, isUserAct) {\r\n    if (isUserAct === void 0) { isUserAct = false; }\r\n    _getLogger(logger)[_DYN_THROW_INTERNAL /* @min:%2ethrowInternal */](severity, msgId, msg, properties, isUserAct);\r\n}\r\n/**\r\n * This is a helper method which will call warnToConsole on the passed logger with the provided message.\r\n * @param logger - The Diagnostic Logger instance to use.\r\n * @param message - {_InternalLogMessage} - The log message.\r\n */\r\nexport function _warnToConsole(logger, message) {\r\n    _getLogger(logger)[_DYN_WARN_TO_CONSOLE /* @min:%2ewarnToConsole */](message);\r\n}\r\n/**\r\n * Logs a message to the internal queue.\r\n * @param logger - The Diagnostic Logger instance to use.\r\n * @param severity - {LoggingSeverity} - The severity of the log message\r\n * @param message - {_InternalLogMessage} - The message to log.\r\n */\r\nexport function _logInternalMessage(logger, severity, message) {\r\n    _getLogger(logger)[_DYN_LOG_INTERNAL_MESSAGE /* @min:%2elogInternalMessage */](severity, message);\r\n}\r\n//# sourceMappingURL=DiagnosticLogger.js.map","var _a, _b;\r\nimport { arrForEach, arrIndexOf, dumpObj, getDocument, getLazy, getNavigator, isArray, isFunction, isNullOrUndefined, isString, isTruthy, isUndefined, objForEachKey, strEndsWith, strIndexOf, strLeft, strSubstring, strTrim, utcNow } from \"@nevware21/ts-utils\";\r\nimport { cfgDfMerge } from \"../Config/ConfigDefaultHelpers\";\r\nimport { createDynamicConfig, onConfigChange } from \"../Config/DynamicConfig\";\r\nimport { _DYN_ENABLED, _DYN_LENGTH, _DYN_LOGGER, _DYN_SET_DF, _DYN_SPLIT, _DYN_UNLOAD, _DYN_USER_AGENT } from \"../__DynamicConstants\";\r\nimport { _throwInternal } from \"./DiagnosticLogger\";\r\nimport { getLocation, isIE } from \"./EnvUtils\";\r\nimport { getExceptionName, isNotNullOrUndefined, setValue, strContains } from \"./HelperFuncs\";\r\nimport { STR_DOMAIN, STR_EMPTY, STR_PATH, UNDEFINED_VALUE } from \"./InternalConstants\";\r\nvar strToGMTString = \"toGMTString\";\r\nvar strToUTCString = \"toUTCString\";\r\nvar strCookie = \"cookie\";\r\nvar strExpires = \"expires\";\r\nvar strIsCookieUseDisabled = \"isCookieUseDisabled\";\r\nvar strDisableCookiesUsage = \"disableCookiesUsage\";\r\nvar strConfigCookieMgr = \"_ckMgr\";\r\nvar _supportsCookies = null;\r\nvar _allowUaSameSite = null;\r\nvar _parsedCookieValue = null;\r\nvar _doc;\r\nvar _cookieCache = {};\r\nvar _globalCookieConfig = {};\r\n// // `isCookieUseDisabled` is deprecated, so explicitly casting as a key of IConfiguration to avoid typing error\r\n// // when both isCookieUseDisabled and disableCookiesUsage are used disableCookiesUsage will take precedent, which is\r\n// // why its listed first\r\n/**\r\n * Set the supported dynamic config values as undefined (or an empty object) so that\r\n * any listeners will be informed of any changes.\r\n * Explicitly NOT including the deprecated `isCookieUseDisabled` as we don't want to support\r\n * the v1 deprecated field as dynamic for updates\r\n */\r\nvar rootDefaultConfig = (_a = {\r\n        cookieCfg: cfgDfMerge((_b = {},\r\n            _b[STR_DOMAIN] = { fb: \"cookieDomain\", dfVal: isNotNullOrUndefined },\r\n            _b.path = { fb: \"cookiePath\", dfVal: isNotNullOrUndefined },\r\n            _b.enabled = UNDEFINED_VALUE,\r\n            _b.ignoreCookies = UNDEFINED_VALUE,\r\n            _b.blockedCookies = UNDEFINED_VALUE,\r\n            _b)),\r\n        cookieDomain: UNDEFINED_VALUE,\r\n        cookiePath: UNDEFINED_VALUE\r\n    },\r\n    _a[strDisableCookiesUsage] = UNDEFINED_VALUE,\r\n    _a);\r\nfunction _getDoc() {\r\n    !_doc && (_doc = getLazy(function () { return getDocument(); }));\r\n}\r\n/**\r\n * @ignore\r\n * DO NOT USE or export from the module, this is exposed as public to support backward compatibility of previous static utility methods only.\r\n * If you want to manager cookies either use the ICookieMgr available from the core instance via getCookieMgr() or create\r\n * your own instance of the CookieMgr and use that.\r\n * Using this directly for enabling / disabling cookie handling will not only affect your usage but EVERY user of cookies.\r\n * Example, if you are using a shared component that is also using Application Insights you will affect their cookie handling.\r\n * @param logger - The DiagnosticLogger to use for reporting errors.\r\n */\r\nfunction _gblCookieMgr(config, logger) {\r\n    // Stash the global instance against the BaseCookieMgr class\r\n    var inst = createCookieMgr[strConfigCookieMgr] || _globalCookieConfig[strConfigCookieMgr];\r\n    if (!inst) {\r\n        // Note: not using the getSetValue() helper as that would require always creating a temporary cookieMgr\r\n        // that ultimately is never used\r\n        inst = createCookieMgr[strConfigCookieMgr] = createCookieMgr(config, logger);\r\n        _globalCookieConfig[strConfigCookieMgr] = inst;\r\n    }\r\n    return inst;\r\n}\r\nfunction _isMgrEnabled(cookieMgr) {\r\n    if (cookieMgr) {\r\n        return cookieMgr.isEnabled();\r\n    }\r\n    return true;\r\n}\r\nfunction _isIgnoredCookie(cookieMgrCfg, name) {\r\n    if (name && cookieMgrCfg && isArray(cookieMgrCfg.ignoreCookies)) {\r\n        return arrIndexOf(cookieMgrCfg.ignoreCookies, name) !== -1;\r\n    }\r\n    return false;\r\n}\r\nfunction _isBlockedCookie(cookieMgrCfg, name) {\r\n    if (name && cookieMgrCfg && isArray(cookieMgrCfg.blockedCookies)) {\r\n        if (arrIndexOf(cookieMgrCfg.blockedCookies, name) !== -1) {\r\n            return true;\r\n        }\r\n    }\r\n    return _isIgnoredCookie(cookieMgrCfg, name);\r\n}\r\nfunction _isCfgEnabled(rootConfig, cookieMgrConfig) {\r\n    var isCfgEnabled = cookieMgrConfig[_DYN_ENABLED /* @min:%2eenabled */];\r\n    if (isNullOrUndefined(isCfgEnabled)) {\r\n        // Set the enabled from the provided setting or the legacy root values\r\n        var cookieEnabled = void 0;\r\n        // This field is deprecated and dynamic updates will not be fully supported\r\n        if (!isUndefined(rootConfig[strIsCookieUseDisabled])) {\r\n            cookieEnabled = !rootConfig[strIsCookieUseDisabled];\r\n        }\r\n        // If this value is defined it takes precedent over the above\r\n        if (!isUndefined(rootConfig[strDisableCookiesUsage])) {\r\n            cookieEnabled = !rootConfig[strDisableCookiesUsage];\r\n        }\r\n        // Not setting the cookieMgrConfig.enabled as that will update (set) the global dynamic config\r\n        // So future \"updates\" then may not be as expected\r\n        isCfgEnabled = cookieEnabled;\r\n    }\r\n    return isCfgEnabled;\r\n}\r\n/**\r\n * Helper to return the ICookieMgr from the core (if not null/undefined) or a default implementation\r\n * associated with the configuration or a legacy default.\r\n * @param core\r\n * @param config\r\n * @returns\r\n */\r\nexport function safeGetCookieMgr(core, config) {\r\n    var cookieMgr;\r\n    if (core) {\r\n        // Always returns an instance\r\n        cookieMgr = core.getCookieMgr();\r\n    }\r\n    else if (config) {\r\n        var cookieCfg = config.cookieCfg;\r\n        if (cookieCfg && cookieCfg[strConfigCookieMgr]) {\r\n            cookieMgr = cookieCfg[strConfigCookieMgr];\r\n        }\r\n        else {\r\n            cookieMgr = createCookieMgr(config);\r\n        }\r\n    }\r\n    if (!cookieMgr) {\r\n        // Get or initialize the default global (legacy) cookie manager if we couldn't find one\r\n        cookieMgr = _gblCookieMgr(config, (core || {})[_DYN_LOGGER /* @min:%2elogger */]);\r\n    }\r\n    return cookieMgr;\r\n}\r\nexport function createCookieMgr(rootConfig, logger) {\r\n    var _a;\r\n    var cookieMgrConfig;\r\n    var _path;\r\n    var _domain;\r\n    var unloadHandler;\r\n    // Explicitly checking against false, so that setting to undefined will === true\r\n    var _enabled;\r\n    var _getCookieFn;\r\n    var _setCookieFn;\r\n    var _delCookieFn;\r\n    // Make sure the root config is dynamic as it may be the global config\r\n    rootConfig = createDynamicConfig(rootConfig || _globalCookieConfig, null, logger).cfg;\r\n    // Will get recalled if the referenced configuration is changed\r\n    unloadHandler = onConfigChange(rootConfig, function (details) {\r\n        // Make sure the root config has all of the the defaults to the root config to ensure they are dynamic\r\n        details[_DYN_SET_DF /* @min:%2esetDf */](details.cfg, rootDefaultConfig);\r\n        // Create and apply the defaults to the cookieCfg element\r\n        cookieMgrConfig = details.ref(details.cfg, \"cookieCfg\"); // details.setDf(details.cfg.cookieCfg, defaultConfig);\r\n        _path = cookieMgrConfig[STR_PATH /* @min:%2epath */] || \"/\";\r\n        _domain = cookieMgrConfig[STR_DOMAIN /* @min:%2edomain */];\r\n        // Explicitly checking against false, so that setting to undefined will === true\r\n        _enabled = _isCfgEnabled(rootConfig, cookieMgrConfig) !== false;\r\n        _getCookieFn = cookieMgrConfig.getCookie || _getCookieValue;\r\n        _setCookieFn = cookieMgrConfig.setCookie || _setCookieValue;\r\n        _delCookieFn = cookieMgrConfig.delCookie || _setCookieValue;\r\n    }, logger);\r\n    var cookieMgr = (_a = {\r\n            isEnabled: function () {\r\n                var enabled = _isCfgEnabled(rootConfig, cookieMgrConfig) !== false && _enabled && areCookiesSupported(logger);\r\n                // Using an indirect lookup for any global cookie manager to support tree shaking for SDK's\r\n                // that don't use the \"applicationinsights-core\" version of the default cookie function\r\n                var gblManager = _globalCookieConfig[strConfigCookieMgr];\r\n                if (enabled && gblManager && cookieMgr !== gblManager) {\r\n                    // Make sure the GlobalCookie Manager instance (if not this instance) is also enabled.\r\n                    // As the global (deprecated) functions may have been called (for backward compatibility)\r\n                    enabled = _isMgrEnabled(gblManager);\r\n                }\r\n                return enabled;\r\n            },\r\n            setEnabled: function (value) {\r\n                // Explicitly checking against false, so that setting to undefined will === true\r\n                _enabled = value !== false;\r\n                cookieMgrConfig[_DYN_ENABLED /* @min:%2eenabled */] = value;\r\n            },\r\n            set: function (name, value, maxAgeSec, domain, path) {\r\n                var result = false;\r\n                if (_isMgrEnabled(cookieMgr) && !_isBlockedCookie(cookieMgrConfig, name)) {\r\n                    var values = {};\r\n                    var theValue = strTrim(value || STR_EMPTY);\r\n                    var idx = strIndexOf(theValue, \";\");\r\n                    if (idx !== -1) {\r\n                        theValue = strTrim(strLeft(value, idx));\r\n                        values = _extractParts(strSubstring(value, idx + 1));\r\n                    }\r\n                    // Only update domain if not already present (isUndefined) and the value is truthy (not null, undefined or empty string)\r\n                    setValue(values, STR_DOMAIN, domain || _domain, isTruthy, isUndefined);\r\n                    if (!isNullOrUndefined(maxAgeSec)) {\r\n                        var _isIE = isIE();\r\n                        if (isUndefined(values[strExpires])) {\r\n                            var nowMs = utcNow();\r\n                            // Only add expires if not already present\r\n                            var expireMs = nowMs + (maxAgeSec * 1000);\r\n                            // Sanity check, if zero or -ve then ignore\r\n                            if (expireMs > 0) {\r\n                                var expiry = new Date();\r\n                                expiry.setTime(expireMs);\r\n                                setValue(values, strExpires, _formatDate(expiry, !_isIE ? strToUTCString : strToGMTString) || _formatDate(expiry, _isIE ? strToGMTString : strToUTCString) || STR_EMPTY, isTruthy);\r\n                            }\r\n                        }\r\n                        if (!_isIE) {\r\n                            // Only replace if not already present\r\n                            setValue(values, \"max-age\", STR_EMPTY + maxAgeSec, null, isUndefined);\r\n                        }\r\n                    }\r\n                    var location_1 = getLocation();\r\n                    if (location_1 && location_1.protocol === \"https:\") {\r\n                        setValue(values, \"secure\", null, null, isUndefined);\r\n                        // Only set same site if not also secure\r\n                        if (_allowUaSameSite === null) {\r\n                            _allowUaSameSite = !uaDisallowsSameSiteNone((getNavigator() || {})[_DYN_USER_AGENT /* @min:%2euserAgent */]);\r\n                        }\r\n                        if (_allowUaSameSite) {\r\n                            setValue(values, \"SameSite\", \"None\", null, isUndefined);\r\n                        }\r\n                    }\r\n                    setValue(values, STR_PATH, path || _path, null, isUndefined);\r\n                    //let setCookieFn = cookieMgrConfig.setCookie || _setCookieValue;\r\n                    _setCookieFn(name, _formatCookieValue(theValue, values));\r\n                    result = true;\r\n                }\r\n                return result;\r\n            },\r\n            get: function (name) {\r\n                var value = STR_EMPTY;\r\n                if (_isMgrEnabled(cookieMgr) && !_isIgnoredCookie(cookieMgrConfig, name)) {\r\n                    value = _getCookieFn(name);\r\n                }\r\n                return value;\r\n            },\r\n            del: function (name, path) {\r\n                var result = false;\r\n                if (_isMgrEnabled(cookieMgr)) {\r\n                    // Only remove the cookie if the manager and cookie support has not been disabled\r\n                    result = cookieMgr.purge(name, path);\r\n                }\r\n                return result;\r\n            },\r\n            purge: function (name, path) {\r\n                var _a;\r\n                var result = false;\r\n                if (areCookiesSupported(logger)) {\r\n                    // Setting the expiration date in the past immediately removes the cookie\r\n                    var values = (_a = {},\r\n                        _a[STR_PATH] = path ? path : \"/\",\r\n                        _a[strExpires] = \"Thu, 01 Jan 1970 00:00:01 GMT\",\r\n                        _a);\r\n                    if (!isIE()) {\r\n                        // Set max age to expire now\r\n                        values[\"max-age\"] = \"0\";\r\n                    }\r\n                    // let delCookie = cookieMgrConfig.delCookie || _setCookieValue;\r\n                    _delCookieFn(name, _formatCookieValue(STR_EMPTY, values));\r\n                    result = true;\r\n                }\r\n                return result;\r\n            }\r\n        },\r\n        _a[_DYN_UNLOAD /* @min:unload */] = function (isAsync) {\r\n            unloadHandler && unloadHandler.rm();\r\n            unloadHandler = null;\r\n        },\r\n        _a);\r\n    // Associated this cookie manager with the config\r\n    cookieMgr[strConfigCookieMgr] = cookieMgr;\r\n    return cookieMgr;\r\n}\r\n/*\r\n* Helper method to tell if document.cookie object is supported by the runtime\r\n*/\r\nexport function areCookiesSupported(logger) {\r\n    if (_supportsCookies === null) {\r\n        _supportsCookies = false;\r\n        !_doc && _getDoc();\r\n        try {\r\n            var doc = _doc.v || {};\r\n            _supportsCookies = doc[strCookie] !== undefined;\r\n        }\r\n        catch (e) {\r\n            _throwInternal(logger, 2 /* eLoggingSeverity.WARNING */, 68 /* _eInternalMessageId.CannotAccessCookie */, \"Cannot access document.cookie - \" + getExceptionName(e), { exception: dumpObj(e) });\r\n        }\r\n    }\r\n    return _supportsCookies;\r\n}\r\nfunction _extractParts(theValue) {\r\n    var values = {};\r\n    if (theValue && theValue[_DYN_LENGTH /* @min:%2elength */]) {\r\n        var parts = strTrim(theValue)[_DYN_SPLIT /* @min:%2esplit */](\";\");\r\n        arrForEach(parts, function (thePart) {\r\n            thePart = strTrim(thePart || STR_EMPTY);\r\n            if (thePart) {\r\n                var idx = strIndexOf(thePart, \"=\");\r\n                if (idx === -1) {\r\n                    values[thePart] = null;\r\n                }\r\n                else {\r\n                    values[strTrim(strLeft(thePart, idx))] = strTrim(strSubstring(thePart, idx + 1));\r\n                }\r\n            }\r\n        });\r\n    }\r\n    return values;\r\n}\r\nfunction _formatDate(theDate, func) {\r\n    if (isFunction(theDate[func])) {\r\n        return theDate[func]();\r\n    }\r\n    return null;\r\n}\r\nfunction _formatCookieValue(value, values) {\r\n    var cookieValue = value || STR_EMPTY;\r\n    objForEachKey(values, function (name, theValue) {\r\n        cookieValue += \"; \" + name + (!isNullOrUndefined(theValue) ? \"=\" + theValue : STR_EMPTY);\r\n    });\r\n    return cookieValue;\r\n}\r\nfunction _getCookieValue(name) {\r\n    var cookieValue = STR_EMPTY;\r\n    !_doc && _getDoc();\r\n    if (_doc.v) {\r\n        var theCookie = _doc.v[strCookie] || STR_EMPTY;\r\n        if (_parsedCookieValue !== theCookie) {\r\n            _cookieCache = _extractParts(theCookie);\r\n            _parsedCookieValue = theCookie;\r\n        }\r\n        cookieValue = strTrim(_cookieCache[name] || STR_EMPTY);\r\n    }\r\n    return cookieValue;\r\n}\r\nfunction _setCookieValue(name, cookieValue) {\r\n    !_doc && _getDoc();\r\n    if (_doc.v) {\r\n        _doc.v[strCookie] = name + \"=\" + cookieValue;\r\n    }\r\n}\r\nexport function uaDisallowsSameSiteNone(userAgent) {\r\n    if (!isString(userAgent)) {\r\n        return false;\r\n    }\r\n    // Cover all iOS based browsers here. This includes:\r\n    // - Safari on iOS 12 for iPhone, iPod Touch, iPad\r\n    // - WkWebview on iOS 12 for iPhone, iPod Touch, iPad\r\n    // - Chrome on iOS 12 for iPhone, iPod Touch, iPad\r\n    // All of which are broken by SameSite=None, because they use the iOS networking stack\r\n    if (strContains(userAgent, \"CPU iPhone OS 12\") || strContains(userAgent, \"iPad; CPU OS 12\")) {\r\n        return true;\r\n    }\r\n    // Cover Mac OS X based browsers that use the Mac OS networking stack. This includes:\r\n    // - Safari on Mac OS X\r\n    // This does not include:\r\n    // - Internal browser on Mac OS X\r\n    // - Chrome on Mac OS X\r\n    // - Chromium on Mac OS X\r\n    // Because they do not use the Mac OS networking stack.\r\n    if (strContains(userAgent, \"Macintosh; Intel Mac OS X 10_14\") && strContains(userAgent, \"Version/\") && strContains(userAgent, \"Safari\")) {\r\n        return true;\r\n    }\r\n    // Cover Mac OS X internal browsers that use the Mac OS networking stack. This includes:\r\n    // - Internal browser on Mac OS X\r\n    // This does not include:\r\n    // - Safari on Mac OS X\r\n    // - Chrome on Mac OS X\r\n    // - Chromium on Mac OS X\r\n    // Because they do not use the Mac OS networking stack.\r\n    if (strContains(userAgent, \"Macintosh; Intel Mac OS X 10_14\") && strEndsWith(userAgent, \"AppleWebKit/605.1.15 (KHTML, like Gecko)\")) {\r\n        return true;\r\n    }\r\n    // Cover Chrome 50-69, because some versions are broken by SameSite=None, and none in this range require it.\r\n    // Note: this covers some pre-Chromium Edge versions, but pre-Chromim Edge does not require SameSite=None, so this is fine.\r\n    // Note: this regex applies to Windows, Mac OS X, and Linux, deliberately.\r\n    if (strContains(userAgent, \"Chrome/5\") || strContains(userAgent, \"Chrome/6\")) {\r\n        return true;\r\n    }\r\n    // Unreal Engine runs Chromium 59, but does not advertise as Chrome until 4.23. Treat versions of Unreal\r\n    // that don't specify their Chrome version as lacking support for SameSite=None.\r\n    if (strContains(userAgent, \"UnrealEngine\") && !strContains(userAgent, \"Chrome\")) {\r\n        return true;\r\n    }\r\n    // UCBrowser < 12.13.2 ignores Set-Cookie headers with SameSite=None\r\n    // NB: this rule isn't complete - you need regex to make a complete rule.\r\n    // See: https://www.chromium.org/updates/same-site/incompatible-clients\r\n    if (strContains(userAgent, \"UCBrowser/12\") || strContains(userAgent, \"UCBrowser/11\")) {\r\n        return true;\r\n    }\r\n    return false;\r\n}\r\n//# sourceMappingURL=CookieMgr.js.map","// Copyright (c) Microsoft Corporation. All rights reserved.\r\n// Licensed under the MIT License.\r\nimport { asString, isBoolean, isFunction, isNullOrUndefined, isString } from \"@nevware21/ts-utils\";\r\nimport { STR_EMPTY } from \"../JavaScriptSDK/InternalConstants\";\r\nimport { _DYN_BLK_VAL, _DYN_TO_LOWER_CASE } from \"../__DynamicConstants\";\r\n/**\r\n * @internal\r\n * @ignore\r\n * @param str\r\n * @param defaultValue\r\n * @returns\r\n */\r\nfunction _stringToBoolOrDefault(theValue, defaultValue, theConfig) {\r\n    if (!theValue && isNullOrUndefined(theValue)) {\r\n        return defaultValue;\r\n    }\r\n    if (isBoolean(theValue)) {\r\n        return theValue;\r\n    }\r\n    return asString(theValue)[_DYN_TO_LOWER_CASE /* @min:%2etoLowerCase */]() === \"true\";\r\n}\r\n/**\r\n * Helper which returns an IConfigDefaultCheck instance with the field defined as an object\r\n * that should be merged\r\n * @param defaultValue - The default value to apply it not provided or it's not valid\r\n * @returns a new IConfigDefaultCheck structure\r\n */\r\nexport function cfgDfMerge(defaultValue) {\r\n    return {\r\n        mrg: true,\r\n        v: defaultValue\r\n    };\r\n}\r\n/**\r\n * Helper which returns an IConfigDefaultCheck instance with the provided field set function\r\n * @param setter - The IConfigCheckFn function to validate the user provided value\r\n * @param defaultValue - The default value to apply it not provided or it's not valid\r\n * @returns a new IConfigDefaultCheck structure\r\n */\r\nexport function cfgDfSet(setter, defaultValue) {\r\n    return {\r\n        set: setter,\r\n        v: defaultValue\r\n    };\r\n}\r\n/**\r\n * Helper which returns an IConfigDefaultCheck instance with the provided field validator\r\n * @param validator - The IConfigCheckFn function to validate the user provided value\r\n * @param defaultValue - The default value to apply it not provided or it's not valid\r\n * @param fallBackName - The fallback configuration name if the current value is not available\r\n * @returns a new IConfigDefaultCheck structure\r\n */\r\nexport function cfgDfValidate(validator, defaultValue, fallBackName) {\r\n    return {\r\n        fb: fallBackName,\r\n        isVal: validator,\r\n        v: defaultValue\r\n    };\r\n}\r\n/**\r\n * Helper which returns an IConfigDefaultCheck instance that will validate and convert the user\r\n * provided value to a boolean from a string or boolean value\r\n * @param defaultValue - The default value to apply it not provided or it's not valid\r\n * @param fallBackName - The fallback configuration name if the current value is not available\r\n * @returns a new IConfigDefaultCheck structure\r\n */\r\nexport function cfgDfBoolean(defaultValue, fallBackName) {\r\n    return {\r\n        fb: fallBackName,\r\n        set: _stringToBoolOrDefault,\r\n        v: !!defaultValue\r\n    };\r\n}\r\n/**\r\n * Helper which returns an IConfigDefaultCheck instance that will validate that the user\r\n * provided value is a function.\r\n * @param defaultValue - The default value to apply it not provided or it's not valid\r\n * @returns a new IConfigDefaultCheck structure\r\n */\r\nexport function cfgDfFunc(defaultValue) {\r\n    return {\r\n        isVal: isFunction,\r\n        v: defaultValue || null\r\n    };\r\n}\r\n/**\r\n * Helper which returns an IConfigDefaultCheck instance that will validate that the user\r\n * provided value is a function.\r\n * @param defaultValue - The default string value to apply it not provided or it's not valid, defaults to an empty string\r\n * @returns a new IConfigDefaultCheck structure\r\n */\r\nexport function cfgDfString(defaultValue) {\r\n    return {\r\n        isVal: isString,\r\n        v: asString(defaultValue || STR_EMPTY)\r\n    };\r\n}\r\n/**\r\n * Helper which returns an IConfigDefaultCheck instance identifying that value associated with this property\r\n * should not have it's properties converted into a dynamic config properties.\r\n * @param defaultValue - The default value to apply it not provided or it's not valid\r\n * @returns a new IConfigDefaultCheck structure\r\n */\r\nexport function cfgDfBlockPropValue(defaultValue) {\r\n    var _a;\r\n    return _a = {},\r\n        _a[_DYN_BLK_VAL /* @min:blkVal */] = true,\r\n        _a.v = defaultValue,\r\n        _a;\r\n}\r\n//# sourceMappingURL=ConfigDefaultHelpers.js.map","// Copyright (c) Microsoft Corporation. All rights reserved.\r\n// Licensed under the MIT License.\r\nimport dynamicProto from \"@microsoft/dynamicproto-js\";\r\nimport { createAllPromise, createPromise, doAwaitResponse } from \"@nevware21/ts-async\";\r\nimport { arrForEach, arrIndexOf, objDefine, scheduleTimeout } from \"@nevware21/ts-utils\";\r\nimport { createDynamicConfig } from \"../Config/DynamicConfig\";\r\nimport { _DYN_ADD_NOTIFICATION_LIS1, _DYN_IS_ASYNC, _DYN_IS_CHILD_EVT, _DYN_PUSH, _DYN_REMOVE_NOTIFICATION_2, _DYN_SPLICE, _DYN_UNLOAD, _DYN_WATCH } from \"../__DynamicConstants\";\r\nimport { STR_EVENTS_DISCARDED, STR_EVENTS_SEND_REQUEST, STR_EVENTS_SENT, STR_PERF_EVENT } from \"./InternalConstants\";\r\nvar defaultValues = {\r\n    perfEvtsSendAll: false\r\n};\r\nfunction _runListeners(listeners, name, isAsync, callback) {\r\n    arrForEach(listeners, function (listener) {\r\n        if (listener && listener[name]) {\r\n            if (isAsync) {\r\n                scheduleTimeout(function () { return callback(listener); }, 0);\r\n            }\r\n            else {\r\n                try {\r\n                    callback(listener);\r\n                }\r\n                catch (e) {\r\n                    // Catch errors to ensure we don't block sending the requests\r\n                }\r\n            }\r\n        }\r\n    });\r\n}\r\n/**\r\n * Class to manage sending notifications to all the listeners.\r\n */\r\nvar NotificationManager = /** @class */ (function () {\r\n    function NotificationManager(config) {\r\n        this.listeners = [];\r\n        var perfEvtsSendAll;\r\n        var unloadHandler;\r\n        var _listeners = [];\r\n        var cfgHandler = createDynamicConfig(config, defaultValues);\r\n        unloadHandler = cfgHandler[_DYN_WATCH /* @min:%2ewatch */](function (details) {\r\n            perfEvtsSendAll = !!details.cfg.perfEvtsSendAll;\r\n        });\r\n        dynamicProto(NotificationManager, this, function (_self) {\r\n            objDefine(_self, \"listeners\", {\r\n                g: function () { return _listeners; }\r\n            });\r\n            _self[_DYN_ADD_NOTIFICATION_LIS1 /* @min:%2eaddNotificationListener */] = function (listener) {\r\n                _listeners[_DYN_PUSH /* @min:%2epush */](listener);\r\n            };\r\n            /**\r\n             * Removes all instances of the listener.\r\n             * @param listener - AWTNotificationListener to remove.\r\n             */\r\n            _self[_DYN_REMOVE_NOTIFICATION_2 /* @min:%2eremoveNotificationListener */] = function (listener) {\r\n                var index = arrIndexOf(_listeners, listener);\r\n                while (index > -1) {\r\n                    _listeners[_DYN_SPLICE /* @min:%2esplice */](index, 1);\r\n                    index = arrIndexOf(_listeners, listener);\r\n                }\r\n            };\r\n            /**\r\n             * Notification for events sent.\r\n             * @param events - The array of events that have been sent.\r\n             */\r\n            _self[STR_EVENTS_SENT /* @min:%2eeventsSent */] = function (events) {\r\n                _runListeners(_listeners, STR_EVENTS_SENT, true, function (listener) {\r\n                    listener[STR_EVENTS_SENT /* @min:%2eeventsSent */](events);\r\n                });\r\n            };\r\n            /**\r\n             * Notification for events being discarded.\r\n             * @param events - The array of events that have been discarded by the SDK.\r\n             * @param reason - The reason for which the SDK discarded the events. The EventsDiscardedReason\r\n             * constant should be used to check the different values.\r\n             */\r\n            _self[STR_EVENTS_DISCARDED /* @min:%2eeventsDiscarded */] = function (events, reason) {\r\n                _runListeners(_listeners, STR_EVENTS_DISCARDED, true, function (listener) {\r\n                    listener[STR_EVENTS_DISCARDED /* @min:%2eeventsDiscarded */](events, reason);\r\n                });\r\n            };\r\n            /**\r\n             * [Optional] A function called when the events have been requested to be sent to the sever.\r\n             * @param sendReason - The reason why the event batch is being sent.\r\n             * @param isAsync - A flag which identifies whether the requests are being sent in an async or sync manner.\r\n             */\r\n            _self[STR_EVENTS_SEND_REQUEST /* @min:%2eeventsSendRequest */] = function (sendReason, isAsync) {\r\n                _runListeners(_listeners, STR_EVENTS_SEND_REQUEST, isAsync, function (listener) {\r\n                    listener[STR_EVENTS_SEND_REQUEST /* @min:%2eeventsSendRequest */](sendReason, isAsync);\r\n                });\r\n            };\r\n            _self[STR_PERF_EVENT /* @min:%2eperfEvent */] = function (perfEvent) {\r\n                if (perfEvent) {\r\n                    // Send all events or only parent events\r\n                    if (perfEvtsSendAll || !perfEvent[_DYN_IS_CHILD_EVT /* @min:%2eisChildEvt */]()) {\r\n                        _runListeners(_listeners, STR_PERF_EVENT, false, function (listener) {\r\n                            if (perfEvent[_DYN_IS_ASYNC /* @min:%2eisAsync */]) {\r\n                                scheduleTimeout(function () { return listener[STR_PERF_EVENT /* @min:%2eperfEvent */](perfEvent); }, 0);\r\n                            }\r\n                            else {\r\n                                listener[STR_PERF_EVENT /* @min:%2eperfEvent */](perfEvent);\r\n                            }\r\n                        });\r\n                    }\r\n                }\r\n            };\r\n            _self[_DYN_UNLOAD /* @min:%2eunload */] = function (isAsync) {\r\n                var _finishUnload = function () {\r\n                    unloadHandler && unloadHandler.rm();\r\n                    unloadHandler = null;\r\n                    _listeners = [];\r\n                };\r\n                var waiting;\r\n                _runListeners(_listeners, \"unload\", false, function (listener) {\r\n                    var asyncUnload = listener[_DYN_UNLOAD /* @min:%2eunload */](isAsync);\r\n                    if (asyncUnload) {\r\n                        if (!waiting) {\r\n                            waiting = [];\r\n                        }\r\n                        waiting[_DYN_PUSH /* @min:%2epush */](asyncUnload);\r\n                    }\r\n                });\r\n                if (waiting) {\r\n                    return createPromise(function (resolve) {\r\n                        return doAwaitResponse(createAllPromise(waiting), function () {\r\n                            _finishUnload();\r\n                            resolve();\r\n                        });\r\n                    });\r\n                }\r\n                else {\r\n                    _finishUnload();\r\n                }\r\n            };\r\n        });\r\n    }\r\n    /**\r\n     * Adds a notification listener.\r\n     * @param listener - The notification listener to be added.\r\n     */\r\n    NotificationManager.prototype.addNotificationListener = function (listener) {\r\n        // @DynamicProtoStub -- DO NOT add any code as this will be removed during packaging\r\n    };\r\n    /**\r\n     * Removes all instances of the listener.\r\n     * @param listener - AWTNotificationListener to remove.\r\n     */\r\n    NotificationManager.prototype.removeNotificationListener = function (listener) {\r\n        // @DynamicProtoStub -- DO NOT add any code as this will be removed during packaging\r\n    };\r\n    /**\r\n     * Notification for events sent.\r\n     * @param events - The array of events that have been sent.\r\n     */\r\n    NotificationManager.prototype.eventsSent = function (events) {\r\n        // @DynamicProtoStub -- DO NOT add any code as this will be removed during packaging\r\n    };\r\n    /**\r\n     * Notification for events being discarded.\r\n     * @param events - The array of events that have been discarded by the SDK.\r\n     * @param reason - The reason for which the SDK discarded the events. The EventsDiscardedReason\r\n     * constant should be used to check the different values.\r\n     */\r\n    NotificationManager.prototype.eventsDiscarded = function (events, reason) {\r\n        // @DynamicProtoStub -- DO NOT add any code as this will be removed during packaging\r\n    };\r\n    /**\r\n     * [Optional] A function called when the events have been requested to be sent to the sever.\r\n     * @param sendReason - The reason why the event batch is being sent.\r\n     * @param isAsync - A flag which identifies whether the requests are being sent in an async or sync manner.\r\n     */\r\n    NotificationManager.prototype.eventsSendRequest = function (sendReason, isAsync) {\r\n        // @DynamicProtoStub -- DO NOT add any code as this will be removed during packaging\r\n    };\r\n    /**\r\n     * [Optional] This event is sent if you have enabled perf events, they are primarily used to track internal performance testing and debugging\r\n     * the event can be displayed via the debug plugin extension.\r\n     * @param perfEvent\r\n     */\r\n    NotificationManager.prototype.perfEvent = function (perfEvent) {\r\n        // @DynamicProtoStub -- DO NOT add any code as this will be removed during packaging\r\n    };\r\n    /**\r\n     * Unload and remove any state that this INotificationManager may be holding, this is generally called when the\r\n     * owning SDK is being unloaded.\r\n     * @param isAsync - Can the unload be performed asynchronously (default)\r\n     * @return If the unload occurs synchronously then nothing should be returned, if happening asynchronously then\r\n     * the function should return an [IPromise](https://nevware21.github.io/ts-async/typedoc/interfaces/IPromise.html)\r\n     * / Promise to allow any listeners to wait for the operation to complete.\r\n     */\r\n    NotificationManager.prototype.unload = function (isAsync) {\r\n        // @DynamicProtoStub -- DO NOT add any code as this will be removed during packaging\r\n    };\r\n    return NotificationManager;\r\n}());\r\nexport { NotificationManager };\r\n//# sourceMappingURL=NotificationManager.js.map","// Copyright (c) Microsoft Corporation. All rights reserved.\r\n// Licensed under the MIT License.\r\nimport dynamicProto from \"@microsoft/dynamicproto-js\";\r\nimport { isArray, isFunction, objDefine, utcNow } from \"@nevware21/ts-utils\";\r\nimport { _DYN_COMPLETE, _DYN_GET_CTX, _DYN_IS_ASYNC, _DYN_IS_CHILD_EVT, _DYN_LENGTH, _DYN_NAME, _DYN_PUSH, _DYN_SET_CTX, _DYN_TIME } from \"../__DynamicConstants\";\r\nimport { STR_GET_PERF_MGR, STR_PERF_EVENT } from \"./InternalConstants\";\r\nvar strExecutionContextKey = \"ctx\";\r\nvar strParentContextKey = \"ParentContextKey\";\r\nvar strChildrenContextKey = \"ChildrenContextKey\";\r\nvar _defaultPerfManager = null;\r\nvar PerfEvent = /** @class */ (function () {\r\n    function PerfEvent(name, payloadDetails, isAsync) {\r\n        var _self = this;\r\n        _self.start = utcNow();\r\n        _self[_DYN_NAME /* @min:%2ename */] = name;\r\n        _self[_DYN_IS_ASYNC /* @min:%2eisAsync */] = isAsync;\r\n        _self[_DYN_IS_CHILD_EVT /* @min:%2eisChildEvt */] = function () { return false; };\r\n        if (isFunction(payloadDetails)) {\r\n            // Create an accessor to minimize the potential performance impact of executing the payloadDetails callback\r\n            var theDetails_1;\r\n            objDefine(_self, \"payload\", {\r\n                g: function () {\r\n                    // Delay the execution of the payloadDetails until needed\r\n                    if (!theDetails_1 && isFunction(payloadDetails)) {\r\n                        theDetails_1 = payloadDetails();\r\n                        // clear it out now so the referenced objects can be garbage collected\r\n                        payloadDetails = null;\r\n                    }\r\n                    return theDetails_1;\r\n                }\r\n            });\r\n        }\r\n        _self[_DYN_GET_CTX /* @min:%2egetCtx */] = function (key) {\r\n            if (key) {\r\n                // The parent and child links are located directly on the object (for better viewing in the DebugPlugin)\r\n                if (key === PerfEvent[strParentContextKey] || key === PerfEvent[strChildrenContextKey]) {\r\n                    return _self[key];\r\n                }\r\n                return (_self[strExecutionContextKey] || {})[key];\r\n            }\r\n            return null;\r\n        };\r\n        _self[_DYN_SET_CTX /* @min:%2esetCtx */] = function (key, value) {\r\n            if (key) {\r\n                // Put the parent and child links directly on the object (for better viewing in the DebugPlugin)\r\n                if (key === PerfEvent[strParentContextKey]) {\r\n                    // Simple assumption, if we are setting a parent then we must be a child\r\n                    if (!_self[key]) {\r\n                        _self[_DYN_IS_CHILD_EVT /* @min:%2eisChildEvt */] = function () { return true; };\r\n                    }\r\n                    _self[key] = value;\r\n                }\r\n                else if (key === PerfEvent[strChildrenContextKey]) {\r\n                    _self[key] = value;\r\n                }\r\n                else {\r\n                    var ctx = _self[strExecutionContextKey] = _self[strExecutionContextKey] || {};\r\n                    ctx[key] = value;\r\n                }\r\n            }\r\n        };\r\n        _self[_DYN_COMPLETE /* @min:%2ecomplete */] = function () {\r\n            var childTime = 0;\r\n            var childEvts = _self[_DYN_GET_CTX /* @min:%2egetCtx */](PerfEvent[strChildrenContextKey]);\r\n            if (isArray(childEvts)) {\r\n                for (var lp = 0; lp < childEvts[_DYN_LENGTH /* @min:%2elength */]; lp++) {\r\n                    var childEvt = childEvts[lp];\r\n                    if (childEvt) {\r\n                        childTime += childEvt[_DYN_TIME /* @min:%2etime */];\r\n                    }\r\n                }\r\n            }\r\n            _self[_DYN_TIME /* @min:%2etime */] = utcNow() - _self.start;\r\n            _self.exTime = _self[_DYN_TIME /* @min:%2etime */] - childTime;\r\n            _self[_DYN_COMPLETE /* @min:%2ecomplete */] = function () { };\r\n        };\r\n    }\r\n    PerfEvent.ParentContextKey = \"parent\";\r\n    PerfEvent.ChildrenContextKey = \"childEvts\";\r\n    return PerfEvent;\r\n}());\r\nexport { PerfEvent };\r\nvar PerfManager = /** @class */ (function () {\r\n    function PerfManager(manager) {\r\n        /**\r\n         * General bucket used for execution context set and retrieved via setCtx() and getCtx.\r\n         * Defined as private so it can be visualized via the DebugPlugin\r\n         */\r\n        this.ctx = {};\r\n        dynamicProto(PerfManager, this, function (_self) {\r\n            _self.create = function (src, payloadDetails, isAsync) {\r\n                // TODO (@MSNev): at some point we will want to add additional configuration to \"select\" which events to instrument\r\n                // for now this is just a simple do everything.\r\n                return new PerfEvent(src, payloadDetails, isAsync);\r\n            };\r\n            _self.fire = function (perfEvent) {\r\n                if (perfEvent) {\r\n                    perfEvent[_DYN_COMPLETE /* @min:%2ecomplete */]();\r\n                    if (manager && isFunction(manager[STR_PERF_EVENT /* @min:%2eperfEvent */])) {\r\n                        manager[STR_PERF_EVENT /* @min:%2eperfEvent */](perfEvent);\r\n                    }\r\n                }\r\n            };\r\n            _self[_DYN_SET_CTX /* @min:%2esetCtx */] = function (key, value) {\r\n                if (key) {\r\n                    var ctx = _self[strExecutionContextKey] = _self[strExecutionContextKey] || {};\r\n                    ctx[key] = value;\r\n                }\r\n            };\r\n            _self[_DYN_GET_CTX /* @min:%2egetCtx */] = function (key) {\r\n                return (_self[strExecutionContextKey] || {})[key];\r\n            };\r\n        });\r\n    }\r\n    /**\r\n     * Create a new event and start timing, the manager may return null/undefined to indicate that it does not\r\n     * want to monitor this source event.\r\n     * @param src - The source name of the event\r\n     * @param payloadDetails - An optional callback function to fetch the payload details for the event.\r\n     * @param isAsync - Is the event occurring from a async event\r\n     */\r\n    PerfManager.prototype.create = function (src, payload, isAsync) {\r\n        // @DynamicProtoStub -- DO NOT add any code as this will be removed during packaging\r\n        return null;\r\n    };\r\n    /**\r\n     * Complete the perfEvent and fire any notifications.\r\n     * @param perfEvent - Fire the event which will also complete the passed event\r\n     */\r\n    PerfManager.prototype.fire = function (perfEvent) {\r\n        // @DynamicProtoStub -- DO NOT add any code as this will be removed during packaging\r\n    };\r\n    /**\r\n     * Set an execution context value\r\n     * @param key - The context key name\r\n     * @param value - The value\r\n     */\r\n    PerfManager.prototype.setCtx = function (key, value) {\r\n        // @DynamicProtoStub -- DO NOT add any code as this will be removed during packaging\r\n    };\r\n    /**\r\n     * Get the execution context value\r\n     * @param key - The context key\r\n     */\r\n    PerfManager.prototype.getCtx = function (key) {\r\n        // @DynamicProtoStub -- DO NOT add any code as this will be removed during packaging\r\n    };\r\n    return PerfManager;\r\n}());\r\nexport { PerfManager };\r\nvar doPerfActiveKey = \"CoreUtils.doPerf\";\r\n/**\r\n * Helper function to wrap a function with a perf event\r\n * @param mgrSource - The Performance Manager or a Performance provider source (may be null)\r\n * @param getSource - The callback to create the source name for the event (if perf monitoring is enabled)\r\n * @param func - The function to call and measure\r\n * @param details - A function to return the payload details\r\n * @param isAsync - Is the event / function being call asynchronously or synchronously\r\n */\r\nexport function doPerf(mgrSource, getSource, func, details, isAsync) {\r\n    if (mgrSource) {\r\n        var perfMgr = mgrSource;\r\n        if (perfMgr[STR_GET_PERF_MGR]) {\r\n            // Looks like a perf manager provider object\r\n            perfMgr = perfMgr[STR_GET_PERF_MGR]();\r\n        }\r\n        if (perfMgr) {\r\n            var perfEvt = void 0;\r\n            var currentActive = perfMgr[_DYN_GET_CTX /* @min:%2egetCtx */](doPerfActiveKey);\r\n            try {\r\n                perfEvt = perfMgr.create(getSource(), details, isAsync);\r\n                if (perfEvt) {\r\n                    if (currentActive && perfEvt[_DYN_SET_CTX /* @min:%2esetCtx */]) {\r\n                        perfEvt[_DYN_SET_CTX /* @min:%2esetCtx */](PerfEvent[strParentContextKey], currentActive);\r\n                        if (currentActive[_DYN_GET_CTX /* @min:%2egetCtx */] && currentActive[_DYN_SET_CTX /* @min:%2esetCtx */]) {\r\n                            var children = currentActive[_DYN_GET_CTX /* @min:%2egetCtx */](PerfEvent[strChildrenContextKey]);\r\n                            if (!children) {\r\n                                children = [];\r\n                                currentActive[_DYN_SET_CTX /* @min:%2esetCtx */](PerfEvent[strChildrenContextKey], children);\r\n                            }\r\n                            children[_DYN_PUSH /* @min:%2epush */](perfEvt);\r\n                        }\r\n                    }\r\n                    // Set this event as the active event now\r\n                    perfMgr[_DYN_SET_CTX /* @min:%2esetCtx */](doPerfActiveKey, perfEvt);\r\n                    return func(perfEvt);\r\n                }\r\n            }\r\n            catch (ex) {\r\n                if (perfEvt && perfEvt[_DYN_SET_CTX /* @min:%2esetCtx */]) {\r\n                    perfEvt[_DYN_SET_CTX /* @min:%2esetCtx */](\"exception\", ex);\r\n                }\r\n            }\r\n            finally {\r\n                // fire the perf event\r\n                if (perfEvt) {\r\n                    perfMgr.fire(perfEvt);\r\n                }\r\n                // Reset the active event to the previous value\r\n                perfMgr[_DYN_SET_CTX /* @min:%2esetCtx */](doPerfActiveKey, currentActive);\r\n            }\r\n        }\r\n    }\r\n    return func();\r\n}\r\n/**\r\n * Set the global performance manager to use when there is no core instance or it has not been initialized yet.\r\n * @param perfManager - The IPerfManager instance to use when no performance manager is supplied.\r\n */\r\nexport function setGblPerfMgr(perfManager) {\r\n    _defaultPerfManager = perfManager;\r\n}\r\n/**\r\n * Get the current global performance manager that will be used with no performance manager is supplied.\r\n * @returns - The current default manager\r\n */\r\nexport function getGblPerfMgr() {\r\n    return _defaultPerfManager;\r\n}\r\n//# sourceMappingURL=PerfManager.js.map","import { isArray, isString, strLeft, strTrim } from \"@nevware21/ts-utils\";\r\nimport { _DYN_LENGTH, _DYN_SPAN_ID, _DYN_TO_LOWER_CASE, _DYN_TRACE_FLAGS, _DYN_TRACE_ID, _DYN_VERSION } from \"../__DynamicConstants\";\r\nimport { generateW3CId } from \"./CoreUtils\";\r\nimport { findMetaTag, findNamedServerTiming } from \"./EnvUtils\";\r\nimport { STR_EMPTY } from \"./InternalConstants\";\r\n// using {0,16} for leading and trailing whitespace just to constrain the possible runtime of a random string\r\nvar TRACE_PARENT_REGEX = /^([\\da-f]{2})-([\\da-f]{32})-([\\da-f]{16})-([\\da-f]{2})(-[^\\s]{1,64})?$/i;\r\nvar DEFAULT_VERSION = \"00\";\r\nvar INVALID_VERSION = \"ff\";\r\nvar INVALID_TRACE_ID = \"00000000000000000000000000000000\";\r\nvar INVALID_SPAN_ID = \"0000000000000000\";\r\nvar SAMPLED_FLAG = 0x01;\r\nfunction _isValid(value, len, invalidValue) {\r\n    if (value && value[_DYN_LENGTH /* @min:%2elength */] === len && value !== invalidValue) {\r\n        return !!value.match(/^[\\da-f]*$/i);\r\n    }\r\n    return false;\r\n}\r\nfunction _formatValue(value, len, defValue) {\r\n    if (_isValid(value, len)) {\r\n        return value;\r\n    }\r\n    return defValue;\r\n}\r\nfunction _formatFlags(value) {\r\n    if (isNaN(value) || value < 0 || value > 255) {\r\n        value = 0x01;\r\n    }\r\n    var result = value.toString(16);\r\n    while (result[_DYN_LENGTH /* @min:%2elength */] < 2) {\r\n        result = \"0\" + result;\r\n    }\r\n    return result;\r\n}\r\n/**\r\n * Create a new ITraceParent instance using the provided values.\r\n * @param traceId - The traceId to use, when invalid a new random W3C id will be generated.\r\n * @param spanId - The parent/span id to use, a new random value will be generated if it is invalid.\r\n * @param flags - The traceFlags to use, defaults to zero (0) if not supplied or invalid\r\n * @param version - The version to used, defaults to version \"01\" if not supplied or invalid.\r\n * @returns\r\n */\r\nexport function createTraceParent(traceId, spanId, flags, version) {\r\n    var _a;\r\n    return _a = {},\r\n        _a[_DYN_VERSION /* @min:version */] = _isValid(version, 2, INVALID_VERSION) ? version : DEFAULT_VERSION,\r\n        _a[_DYN_TRACE_ID /* @min:traceId */] = isValidTraceId(traceId) ? traceId : generateW3CId(),\r\n        _a[_DYN_SPAN_ID /* @min:spanId */] = isValidSpanId(spanId) ? spanId : strLeft(generateW3CId(), 16),\r\n        _a.traceFlags = flags >= 0 && flags <= 0xFF ? flags : 1,\r\n        _a;\r\n}\r\n/**\r\n * Attempt to parse the provided string as a W3C TraceParent header value (https://www.w3.org/TR/trace-context/#traceparent-header)\r\n *\r\n * @param value\r\n * @returns\r\n */\r\nexport function parseTraceParent(value) {\r\n    var _a;\r\n    if (!value) {\r\n        // Don't pass a null/undefined or empty string\r\n        return null;\r\n    }\r\n    if (isArray(value)) {\r\n        // The value may have been encoded on the page into an array so handle this automatically\r\n        value = value[0] || \"\";\r\n    }\r\n    if (!value || !isString(value) || value[_DYN_LENGTH /* @min:%2elength */] > 8192) {\r\n        // limit potential processing based on total length\r\n        return null;\r\n    }\r\n    // See https://www.w3.org/TR/trace-context/#versioning-of-traceparent\r\n    var match = TRACE_PARENT_REGEX.exec(strTrim(value));\r\n    if (!match || // No match\r\n        match[1] === INVALID_VERSION || // version ff is forbidden\r\n        match[2] === INVALID_TRACE_ID || // All zeros is considered to be invalid\r\n        match[3] === INVALID_SPAN_ID) { // All zeros is considered to be invalid\r\n        return null;\r\n    }\r\n    return _a = {\r\n            version: (match[1] || STR_EMPTY)[_DYN_TO_LOWER_CASE /* @min:%2etoLowerCase */](),\r\n            traceId: (match[2] || STR_EMPTY)[_DYN_TO_LOWER_CASE /* @min:%2etoLowerCase */](),\r\n            spanId: (match[3] || STR_EMPTY)[_DYN_TO_LOWER_CASE /* @min:%2etoLowerCase */]()\r\n        },\r\n        _a[_DYN_TRACE_FLAGS /* @min:traceFlags */] = parseInt(match[4], 16),\r\n        _a;\r\n}\r\n/**\r\n * Is the provided W3c Trace Id a valid string representation, it must be a 32-character string\r\n * of lowercase hexadecimal characters for example, 4bf92f3577b34da6a3ce929d0e0e4736.\r\n * If all characters as zero (00000000000000000000000000000000) it will be considered an invalid value.\r\n * @param value - The W3c trace Id to be validated\r\n * @returns true if valid otherwise false\r\n */\r\nexport function isValidTraceId(value) {\r\n    return _isValid(value, 32, INVALID_TRACE_ID);\r\n}\r\n/**\r\n * Is the provided W3c span id (aka. parent id) a valid string representation, it must be a 16-character\r\n * string of lowercase hexadecimal characters, for example, 00f067aa0ba902b7.\r\n * If all characters are zero (0000000000000000) this is considered an invalid value.\r\n * @param value - The W3c span id to be validated\r\n * @returns true if valid otherwise false\r\n */\r\nexport function isValidSpanId(value) {\r\n    return _isValid(value, 16, INVALID_SPAN_ID);\r\n}\r\n/**\r\n * Validates that the provided ITraceParent instance conforms to the currently supported specifications\r\n * @param value\r\n * @returns\r\n */\r\nexport function isValidTraceParent(value) {\r\n    if (!value ||\r\n        !_isValid(value[_DYN_VERSION /* @min:%2eversion */], 2, INVALID_VERSION) ||\r\n        !_isValid(value[_DYN_TRACE_ID /* @min:%2etraceId */], 32, INVALID_TRACE_ID) ||\r\n        !_isValid(value[_DYN_SPAN_ID /* @min:%2espanId */], 16, INVALID_SPAN_ID) ||\r\n        !_isValid(_formatFlags(value[_DYN_TRACE_FLAGS /* @min:%2etraceFlags */]), 2)) {\r\n        // Each known field must contain a valid value\r\n        return false;\r\n    }\r\n    return true;\r\n}\r\n/**\r\n * Is the parsed traceParent indicating that the trace is currently sampled.\r\n * @param value - The parsed traceParent value\r\n * @returns\r\n */\r\nexport function isSampledFlag(value) {\r\n    if (isValidTraceParent(value)) {\r\n        return (value[_DYN_TRACE_FLAGS /* @min:%2etraceFlags */] & SAMPLED_FLAG) === SAMPLED_FLAG;\r\n    }\r\n    return false;\r\n}\r\n/**\r\n * Format the ITraceParent value as a string using the supported and know version formats.\r\n * So even if the passed traceParent is a later version the string value returned from this\r\n * function will convert it to only the known version formats.\r\n * This currently only supports version \"00\" and invalid \"ff\"\r\n * @param value - The parsed traceParent value\r\n * @returns\r\n */\r\nexport function formatTraceParent(value) {\r\n    if (value) {\r\n        // Special Note: This only supports formatting as version 00, future versions should encode any known supported version\r\n        // So parsing a future version will populate the correct version value but reformatting will reduce it to version 00.\r\n        var flags = _formatFlags(value[_DYN_TRACE_FLAGS /* @min:%2etraceFlags */]);\r\n        if (!_isValid(flags, 2)) {\r\n            flags = \"01\";\r\n        }\r\n        var version = value[_DYN_VERSION /* @min:%2eversion */] || DEFAULT_VERSION;\r\n        if (version !== \"00\" && version !== \"ff\") {\r\n            // Reduce version to \"00\"\r\n            version = DEFAULT_VERSION;\r\n        }\r\n        // Format as version 00\r\n        return \"\".concat(version.toLowerCase(), \"-\").concat(_formatValue(value.traceId, 32, INVALID_TRACE_ID).toLowerCase(), \"-\").concat(_formatValue(value.spanId, 16, INVALID_SPAN_ID).toLowerCase(), \"-\").concat(flags.toLowerCase());\r\n    }\r\n    return \"\";\r\n}\r\n/**\r\n * Helper function to fetch the passed traceparent from the page, looking for it as a meta-tag or a Server-Timing header.\r\n * @returns\r\n */\r\nexport function findW3cTraceParent() {\r\n    var name = \"traceparent\";\r\n    var traceParent = parseTraceParent(findMetaTag(name));\r\n    if (!traceParent) {\r\n        traceParent = parseTraceParent(findNamedServerTiming(name));\r\n    }\r\n    return traceParent;\r\n}\r\n//# sourceMappingURL=W3cTraceParent.js.map","// Copyright (c) Microsoft Corporation. All rights reserved.\r\n// Licensed under the MIT License.\r\n\"use strict\";\r\nimport { arrForEach, isFunction } from \"@nevware21/ts-utils\";\r\nimport { _DYN_GET_NEXT, _DYN_GET_PLUGIN, _DYN_INITIALIZE, _DYN_IS_INITIALIZED, _DYN_LENGTH, _DYN_NAME, _DYN_PUSH, _DYN_SET_NEXT_PLUGIN, _DYN_SPAN_ID, _DYN_TEARDOWN, _DYN_TRACE_FLAGS, _DYN_TRACE_ID, _DYN__DO_TEARDOWN } from \"../__DynamicConstants\";\r\nimport { createElmNodeData } from \"./DataCacheHelper\";\r\nimport { STR_CORE, STR_PRIORITY, STR_PROCESS_TELEMETRY } from \"./InternalConstants\";\r\nimport { isValidSpanId, isValidTraceId } from \"./W3cTraceParent\";\r\nvar pluginStateData = createElmNodeData(\"plugin\");\r\nexport function _getPluginState(plugin) {\r\n    return pluginStateData.get(plugin, \"state\", {}, true);\r\n}\r\n/**\r\n * Initialize the queue of plugins\r\n * @param plugins - The array of plugins to initialize and setting of the next plugin\r\n * @param config - The current config for the instance\r\n * @param core - THe current core instance\r\n * @param extensions - The extensions\r\n */\r\nexport function initializePlugins(processContext, extensions) {\r\n    // Set the next plugin and identified the uninitialized plugins\r\n    var initPlugins = [];\r\n    var lastPlugin = null;\r\n    var proxy = processContext[_DYN_GET_NEXT /* @min:%2egetNext */]();\r\n    var pluginState;\r\n    while (proxy) {\r\n        var thePlugin = proxy[_DYN_GET_PLUGIN /* @min:%2egetPlugin */]();\r\n        if (thePlugin) {\r\n            if (lastPlugin && lastPlugin[_DYN_SET_NEXT_PLUGIN /* @min:%2esetNextPlugin */] && thePlugin[STR_PROCESS_TELEMETRY /* @min:%2eprocessTelemetry */]) {\r\n                // Set this plugin as the next for the previous one\r\n                lastPlugin[_DYN_SET_NEXT_PLUGIN /* @min:%2esetNextPlugin */](thePlugin);\r\n            }\r\n            pluginState = _getPluginState(thePlugin);\r\n            var isInitialized = !!pluginState[_DYN_IS_INITIALIZED /* @min:%2eisInitialized */];\r\n            if (thePlugin[_DYN_IS_INITIALIZED /* @min:%2eisInitialized */]) {\r\n                isInitialized = thePlugin[_DYN_IS_INITIALIZED /* @min:%2eisInitialized */]();\r\n            }\r\n            if (!isInitialized) {\r\n                initPlugins[_DYN_PUSH /* @min:%2epush */](thePlugin);\r\n            }\r\n            lastPlugin = thePlugin;\r\n            proxy = proxy[_DYN_GET_NEXT /* @min:%2egetNext */]();\r\n        }\r\n    }\r\n    // Now initialize the plugins\r\n    arrForEach(initPlugins, function (thePlugin) {\r\n        var core = processContext[STR_CORE /* @min:%2ecore */]();\r\n        thePlugin[_DYN_INITIALIZE /* @min:%2einitialize */](processContext.getCfg(), core, extensions, processContext[_DYN_GET_NEXT /* @min:%2egetNext */]());\r\n        pluginState = _getPluginState(thePlugin);\r\n        // Only add the core to the state if the plugin didn't set it (doesn't extend from BaseTelemetryPlugin)\r\n        if (!thePlugin[STR_CORE] && !pluginState[STR_CORE]) {\r\n            pluginState[STR_CORE] = core;\r\n        }\r\n        pluginState[_DYN_IS_INITIALIZED /* @min:%2eisInitialized */] = true;\r\n        delete pluginState[_DYN_TEARDOWN /* @min:%2eteardown */];\r\n    });\r\n}\r\nexport function sortPlugins(plugins) {\r\n    // Sort by priority\r\n    return plugins.sort(function (extA, extB) {\r\n        var result = 0;\r\n        if (extB) {\r\n            var bHasProcess = extB[STR_PROCESS_TELEMETRY];\r\n            if (extA[STR_PROCESS_TELEMETRY]) {\r\n                result = bHasProcess ? extA[STR_PRIORITY] - extB[STR_PRIORITY] : 1;\r\n            }\r\n            else if (bHasProcess) {\r\n                result = -1;\r\n            }\r\n        }\r\n        else {\r\n            result = extA ? 1 : -1;\r\n        }\r\n        return result;\r\n    });\r\n    // sort complete\r\n}\r\n/**\r\n * Teardown / Unload helper to perform teardown/unloading operations for the provided components synchronously or asynchronously, this will call any\r\n * _doTeardown() or _doUnload() functions on the provided components to allow them to finish removal.\r\n * @param components - The components you want to unload\r\n * @param unloadCtx - This is the context that should be used during unloading.\r\n * @param unloadState - The details / state of the unload process, it holds details like whether it should be unloaded synchronously or asynchronously and the reason for the unload.\r\n * @param asyncCallback - An optional callback that the plugin must call if it returns true to inform the caller that it has completed any async unload/teardown operations.\r\n * @returns boolean - true if the plugin has or will call asyncCallback, this allows the plugin to perform any asynchronous operations.\r\n */\r\nexport function unloadComponents(components, unloadCtx, unloadState, asyncCallback) {\r\n    var idx = 0;\r\n    function _doUnload() {\r\n        while (idx < components[_DYN_LENGTH /* @min:%2elength */]) {\r\n            var component = components[idx++];\r\n            if (component) {\r\n                var func = component._doUnload || component[_DYN__DO_TEARDOWN /* @min:%2e_doTeardown */];\r\n                if (isFunction(func)) {\r\n                    if (func.call(component, unloadCtx, unloadState, _doUnload) === true) {\r\n                        return true;\r\n                    }\r\n                }\r\n            }\r\n        }\r\n    }\r\n    return _doUnload();\r\n}\r\n/**\r\n * Creates a IDistributedTraceContext which optionally also \"sets\" the value on a parent\r\n * @param parentCtx - An optional parent distributed trace instance\r\n * @returns A new IDistributedTraceContext instance that uses an internal temporary object\r\n */\r\nexport function createDistributedTraceContext(parentCtx) {\r\n    var trace = {};\r\n    return {\r\n        getName: function () {\r\n            return trace[_DYN_NAME /* @min:%2ename */];\r\n        },\r\n        setName: function (newValue) {\r\n            parentCtx && parentCtx.setName(newValue);\r\n            trace[_DYN_NAME /* @min:%2ename */] = newValue;\r\n        },\r\n        getTraceId: function () {\r\n            return trace[_DYN_TRACE_ID /* @min:%2etraceId */];\r\n        },\r\n        setTraceId: function (newValue) {\r\n            parentCtx && parentCtx.setTraceId(newValue);\r\n            if (isValidTraceId(newValue)) {\r\n                trace[_DYN_TRACE_ID /* @min:%2etraceId */] = newValue;\r\n            }\r\n        },\r\n        getSpanId: function () {\r\n            return trace[_DYN_SPAN_ID /* @min:%2espanId */];\r\n        },\r\n        setSpanId: function (newValue) {\r\n            parentCtx && parentCtx.setSpanId(newValue);\r\n            if (isValidSpanId(newValue)) {\r\n                trace[_DYN_SPAN_ID /* @min:%2espanId */] = newValue;\r\n            }\r\n        },\r\n        getTraceFlags: function () {\r\n            return trace[_DYN_TRACE_FLAGS /* @min:%2etraceFlags */];\r\n        },\r\n        setTraceFlags: function (newTraceFlags) {\r\n            parentCtx && parentCtx.setTraceFlags(newTraceFlags);\r\n            trace[_DYN_TRACE_FLAGS /* @min:%2etraceFlags */] = newTraceFlags;\r\n        }\r\n    };\r\n}\r\n//# sourceMappingURL=TelemetryHelpers.js.map","// Copyright (c) Microsoft Corporation. All rights reserved.\r\n// Licensed under the MIT License.\r\n\"use strict\";\r\nimport { arrForEach, dumpObj, isArray, isFunction, isNullOrUndefined, isUndefined, objForEachKey, objFreeze, objKeys } from \"@nevware21/ts-utils\";\r\nimport { _applyDefaultValue } from \"../Config/ConfigDefaults\";\r\nimport { createDynamicConfig } from \"../Config/DynamicConfig\";\r\nimport { _DYN_CREATE_NEW, _DYN_DIAG_LOG, _DYN_GET_NEXT, _DYN_GET_PLUGIN, _DYN_IDENTIFIER, _DYN_IS_ASYNC, _DYN_IS_INITIALIZED, _DYN_LENGTH, _DYN_LOGGER, _DYN_PROCESS_NEXT, _DYN_PUSH, _DYN_SET_DF, _DYN_SET_NEXT_PLUGIN, _DYN_TEARDOWN, _DYN_UNLOAD, _DYN_UPDATE } from \"../__DynamicConstants\";\r\nimport { _throwInternal, safeGetLogger } from \"./DiagnosticLogger\";\r\nimport { proxyFunctions } from \"./HelperFuncs\";\r\nimport { STR_CORE, STR_DISABLED, STR_EMPTY, STR_EXTENSION_CONFIG, STR_PRIORITY, STR_PROCESS_TELEMETRY } from \"./InternalConstants\";\r\nimport { doPerf } from \"./PerfManager\";\r\nimport { _getPluginState } from \"./TelemetryHelpers\";\r\nvar strTelemetryPluginChain = \"TelemetryPluginChain\";\r\nvar strHasRunFlags = \"_hasRun\";\r\nvar strGetTelCtx = \"_getTelCtx\";\r\nvar _chainId = 0;\r\nfunction _getNextProxyStart(proxy, core, startAt) {\r\n    while (proxy) {\r\n        if (proxy[_DYN_GET_PLUGIN /* @min:%2egetPlugin */]() === startAt) {\r\n            return proxy;\r\n        }\r\n        proxy = proxy[_DYN_GET_NEXT /* @min:%2egetNext */]();\r\n    }\r\n    // This wasn't found in the existing chain so create an isolated one with just this plugin\r\n    return createTelemetryProxyChain([startAt], core.config || {}, core);\r\n}\r\n/**\r\n * @ignore\r\n * @param telemetryChain\r\n * @param dynamicHandler\r\n * @param core\r\n * @param startAt - Identifies the next plugin to execute, if null there is no \"next\" plugin and if undefined it should assume the start of the chain\r\n * @returns\r\n */\r\nfunction _createInternalContext(telemetryChain, dynamicHandler, core, startAt) {\r\n    // We have a special case where we want to start execution from this specific plugin\r\n    // or we simply reuse the existing telemetry plugin chain (normal execution case)\r\n    var _nextProxy = null; // By Default set as no next plugin\r\n    var _onComplete = [];\r\n    if (!dynamicHandler) {\r\n        dynamicHandler = createDynamicConfig({}, null, core[_DYN_LOGGER /* @min:%2elogger */]);\r\n    }\r\n    if (startAt !== null) {\r\n        // There is no next element (null) vs not defined (undefined) so use the full chain\r\n        _nextProxy = startAt ? _getNextProxyStart(telemetryChain, core, startAt) : telemetryChain;\r\n    }\r\n    var context = {\r\n        _next: _moveNext,\r\n        ctx: {\r\n            core: function () {\r\n                return core;\r\n            },\r\n            diagLog: function () {\r\n                return safeGetLogger(core, dynamicHandler.cfg);\r\n            },\r\n            getCfg: function () {\r\n                return dynamicHandler.cfg;\r\n            },\r\n            getExtCfg: _resolveExtCfg,\r\n            getConfig: _getConfig,\r\n            hasNext: function () {\r\n                return !!_nextProxy;\r\n            },\r\n            getNext: function () {\r\n                return _nextProxy;\r\n            },\r\n            setNext: function (nextPlugin) {\r\n                _nextProxy = nextPlugin;\r\n            },\r\n            iterate: _iterateChain,\r\n            onComplete: _addOnComplete\r\n        }\r\n    };\r\n    function _addOnComplete(onComplete, that) {\r\n        var args = [];\r\n        for (var _i = 2; _i < arguments.length; _i++) {\r\n            args[_i - 2] = arguments[_i];\r\n        }\r\n        if (onComplete) {\r\n            _onComplete[_DYN_PUSH /* @min:%2epush */]({\r\n                func: onComplete,\r\n                self: !isUndefined(that) ? that : context.ctx,\r\n                args: args\r\n            });\r\n        }\r\n    }\r\n    function _moveNext() {\r\n        var nextProxy = _nextProxy;\r\n        // Automatically move to the next plugin\r\n        _nextProxy = nextProxy ? nextProxy[_DYN_GET_NEXT /* @min:%2egetNext */]() : null;\r\n        if (!nextProxy) {\r\n            var onComplete = _onComplete;\r\n            if (onComplete && onComplete[_DYN_LENGTH /* @min:%2elength */] > 0) {\r\n                arrForEach(onComplete, function (completeDetails) {\r\n                    try {\r\n                        completeDetails.func.call(completeDetails.self, completeDetails.args);\r\n                    }\r\n                    catch (e) {\r\n                        _throwInternal(core[_DYN_LOGGER /* @min:%2elogger */], 2 /* eLoggingSeverity.WARNING */, 73 /* _eInternalMessageId.PluginException */, \"Unexpected Exception during onComplete - \" + dumpObj(e));\r\n                    }\r\n                });\r\n                _onComplete = [];\r\n            }\r\n        }\r\n        return nextProxy;\r\n    }\r\n    function _getExtCfg(identifier, createIfMissing) {\r\n        var idCfg = null;\r\n        var cfg = dynamicHandler.cfg;\r\n        if (cfg && identifier) {\r\n            var extCfg = cfg[STR_EXTENSION_CONFIG /* @min:%2eextensionConfig */];\r\n            if (!extCfg && createIfMissing) {\r\n                extCfg = {};\r\n            }\r\n            // Always set the value so that the property always exists\r\n            cfg[STR_EXTENSION_CONFIG] = extCfg; // Note: it is valid for the \"value\" to be undefined\r\n            // Calling `ref()` has a side effect of causing the referenced property to become dynamic  (if not already)\r\n            extCfg = dynamicHandler.ref(cfg, STR_EXTENSION_CONFIG);\r\n            if (extCfg) {\r\n                idCfg = extCfg[identifier];\r\n                if (!idCfg && createIfMissing) {\r\n                    idCfg = {};\r\n                }\r\n                // Always set the value so that the property always exists\r\n                extCfg[identifier] = idCfg; // Note: it is valid for the \"value\" to be undefined\r\n                // Calling `ref()` has a side effect of causing the referenced property to become dynamic  (if not already)\r\n                idCfg = dynamicHandler.ref(extCfg, identifier);\r\n            }\r\n        }\r\n        return idCfg;\r\n    }\r\n    function _resolveExtCfg(identifier, defaultValues) {\r\n        var newConfig = _getExtCfg(identifier, true);\r\n        if (defaultValues) {\r\n            // Enumerate over the defaultValues and if not already populated attempt to\r\n            // find a value from the root config or use the default value\r\n            objForEachKey(defaultValues, function (field, defaultValue) {\r\n                // for each unspecified field, set the default value\r\n                if (isNullOrUndefined(newConfig[field])) {\r\n                    var cfgValue = dynamicHandler.cfg[field];\r\n                    if (cfgValue || !isNullOrUndefined(cfgValue)) {\r\n                        newConfig[field] = cfgValue;\r\n                    }\r\n                }\r\n                _applyDefaultValue(dynamicHandler, newConfig, field, defaultValue);\r\n            });\r\n        }\r\n        return dynamicHandler[_DYN_SET_DF /* @min:%2esetDf */](newConfig, defaultValues);\r\n    }\r\n    function _getConfig(identifier, field, defaultValue) {\r\n        if (defaultValue === void 0) { defaultValue = false; }\r\n        var theValue;\r\n        var extConfig = _getExtCfg(identifier, false);\r\n        var rootConfig = dynamicHandler.cfg;\r\n        if (extConfig && (extConfig[field] || !isNullOrUndefined(extConfig[field]))) {\r\n            theValue = extConfig[field];\r\n        }\r\n        else if (rootConfig[field] || !isNullOrUndefined(rootConfig[field])) {\r\n            theValue = rootConfig[field];\r\n        }\r\n        return (theValue || !isNullOrUndefined(theValue)) ? theValue : defaultValue;\r\n    }\r\n    function _iterateChain(cb) {\r\n        // Keep processing until we reach the end of the chain\r\n        var nextPlugin;\r\n        while (!!(nextPlugin = context._next())) {\r\n            var plugin = nextPlugin[_DYN_GET_PLUGIN /* @min:%2egetPlugin */]();\r\n            if (plugin) {\r\n                // callback with the current on\r\n                cb(plugin);\r\n            }\r\n        }\r\n    }\r\n    return context;\r\n}\r\n/**\r\n * Creates a new Telemetry Item context with the current config, core and plugin execution chain\r\n * @param plugins - The plugin instances that will be executed\r\n * @param config - The current config\r\n * @param core - The current core instance\r\n * @param startAt - Identifies the next plugin to execute, if null there is no \"next\" plugin and if undefined it should assume the start of the chain\r\n */\r\nexport function createProcessTelemetryContext(telemetryChain, cfg, core, startAt) {\r\n    var config = createDynamicConfig(cfg);\r\n    var internalContext = _createInternalContext(telemetryChain, config, core, startAt);\r\n    var context = internalContext.ctx;\r\n    function _processNext(env) {\r\n        var nextPlugin = internalContext._next();\r\n        if (nextPlugin) {\r\n            // Run the next plugin which will call \"processNext()\"\r\n            nextPlugin[STR_PROCESS_TELEMETRY /* @min:%2eprocessTelemetry */](env, context);\r\n        }\r\n        return !nextPlugin;\r\n    }\r\n    function _createNew(plugins, startAt) {\r\n        if (plugins === void 0) { plugins = null; }\r\n        if (isArray(plugins)) {\r\n            plugins = createTelemetryProxyChain(plugins, config.cfg, core, startAt);\r\n        }\r\n        return createProcessTelemetryContext(plugins || context[_DYN_GET_NEXT /* @min:%2egetNext */](), config.cfg, core, startAt);\r\n    }\r\n    context[_DYN_PROCESS_NEXT /* @min:%2eprocessNext */] = _processNext;\r\n    context[_DYN_CREATE_NEW /* @min:%2ecreateNew */] = _createNew;\r\n    return context;\r\n}\r\n/**\r\n * Creates a new Telemetry Item context with the current config, core and plugin execution chain for handling the unloading of the chain\r\n * @param plugins - The plugin instances that will be executed\r\n * @param config - The current config\r\n * @param core - The current core instance\r\n * @param startAt - Identifies the next plugin to execute, if null there is no \"next\" plugin and if undefined it should assume the start of the chain\r\n */\r\nexport function createProcessTelemetryUnloadContext(telemetryChain, core, startAt) {\r\n    var config = createDynamicConfig(core.config);\r\n    var internalContext = _createInternalContext(telemetryChain, config, core, startAt);\r\n    var context = internalContext.ctx;\r\n    function _processNext(unloadState) {\r\n        var nextPlugin = internalContext._next();\r\n        nextPlugin && nextPlugin[_DYN_UNLOAD /* @min:%2eunload */](context, unloadState);\r\n        return !nextPlugin;\r\n    }\r\n    function _createNew(plugins, startAt) {\r\n        if (plugins === void 0) { plugins = null; }\r\n        if (isArray(plugins)) {\r\n            plugins = createTelemetryProxyChain(plugins, config.cfg, core, startAt);\r\n        }\r\n        return createProcessTelemetryUnloadContext(plugins || context[_DYN_GET_NEXT /* @min:%2egetNext */](), core, startAt);\r\n    }\r\n    context[_DYN_PROCESS_NEXT /* @min:%2eprocessNext */] = _processNext;\r\n    context[_DYN_CREATE_NEW /* @min:%2ecreateNew */] = _createNew;\r\n    return context;\r\n}\r\n/**\r\n * Creates a new Telemetry Item context with the current config, core and plugin execution chain for updating the configuration\r\n * @param plugins - The plugin instances that will be executed\r\n * @param config - The current config\r\n * @param core - The current core instance\r\n * @param startAt - Identifies the next plugin to execute, if null there is no \"next\" plugin and if undefined it should assume the start of the chain\r\n */\r\nexport function createProcessTelemetryUpdateContext(telemetryChain, core, startAt) {\r\n    var config = createDynamicConfig(core.config);\r\n    var internalContext = _createInternalContext(telemetryChain, config, core, startAt);\r\n    var context = internalContext.ctx;\r\n    function _processNext(updateState) {\r\n        return context.iterate(function (plugin) {\r\n            if (isFunction(plugin[_DYN_UPDATE /* @min:%2eupdate */])) {\r\n                plugin[_DYN_UPDATE /* @min:%2eupdate */](context, updateState);\r\n            }\r\n        });\r\n    }\r\n    function _createNew(plugins, startAt) {\r\n        if (plugins === void 0) { plugins = null; }\r\n        if (isArray(plugins)) {\r\n            plugins = createTelemetryProxyChain(plugins, config.cfg, core, startAt);\r\n        }\r\n        return createProcessTelemetryUpdateContext(plugins || context[_DYN_GET_NEXT /* @min:%2egetNext */](), core, startAt);\r\n    }\r\n    context[_DYN_PROCESS_NEXT /* @min:%2eprocessNext */] = _processNext;\r\n    context[_DYN_CREATE_NEW /* @min:%2ecreateNew */] = _createNew;\r\n    return context;\r\n}\r\n/**\r\n * Creates an execution chain from the array of plugins\r\n * @param plugins - The array of plugins that will be executed in this order\r\n * @param defItemCtx - The default execution context to use when no telemetry context is passed to processTelemetry(), this\r\n * should be for legacy plugins only. Currently, only used for passing the current core instance and to provide better error\r\n * reporting (hasRun) when errors occur.\r\n */\r\nexport function createTelemetryProxyChain(plugins, config, core, startAt) {\r\n    var firstProxy = null;\r\n    var add = startAt ? false : true;\r\n    if (isArray(plugins) && plugins[_DYN_LENGTH /* @min:%2elength */] > 0) {\r\n        // Create the proxies and wire up the next plugin chain\r\n        var lastProxy_1 = null;\r\n        arrForEach(plugins, function (thePlugin) {\r\n            if (!add && startAt === thePlugin) {\r\n                add = true;\r\n            }\r\n            if (add && thePlugin && isFunction(thePlugin[STR_PROCESS_TELEMETRY /* @min:%2eprocessTelemetry */])) {\r\n                // Only add plugins that are processors\r\n                var newProxy = createTelemetryPluginProxy(thePlugin, config, core);\r\n                if (!firstProxy) {\r\n                    firstProxy = newProxy;\r\n                }\r\n                if (lastProxy_1) {\r\n                    // Set this new proxy as the next for the previous one\r\n                    lastProxy_1._setNext(newProxy);\r\n                }\r\n                lastProxy_1 = newProxy;\r\n            }\r\n        });\r\n    }\r\n    if (startAt && !firstProxy) {\r\n        // Special case where the \"startAt\" was not in the original list of plugins\r\n        return createTelemetryProxyChain([startAt], config, core);\r\n    }\r\n    return firstProxy;\r\n}\r\n/**\r\n * Create the processing telemetry proxy instance, the proxy is used to abstract the current plugin to allow monitoring and\r\n * execution plugins while passing around the dynamic execution state (IProcessTelemetryContext), the proxy instance no longer\r\n * contains any execution state and can be reused between requests (this was not the case for 2.7.2 and earlier with the\r\n * TelemetryPluginChain class).\r\n * @param plugin - The plugin instance to proxy\r\n * @param config - The default execution context to use when no telemetry context is passed to processTelemetry(), this\r\n * should be for legacy plugins only. Currently, only used for passing the current core instance and to provide better error\r\n * reporting (hasRun) when errors occur.\r\n * @returns\r\n */\r\nexport function createTelemetryPluginProxy(plugin, config, core) {\r\n    var nextProxy = null;\r\n    var hasProcessTelemetry = isFunction(plugin[STR_PROCESS_TELEMETRY /* @min:%2eprocessTelemetry */]);\r\n    var hasSetNext = isFunction(plugin[_DYN_SET_NEXT_PLUGIN /* @min:%2esetNextPlugin */]);\r\n    var chainId;\r\n    if (plugin) {\r\n        chainId = plugin[_DYN_IDENTIFIER /* @min:%2eidentifier */] + \"-\" + plugin[STR_PRIORITY /* @min:%2epriority */] + \"-\" + _chainId++;\r\n    }\r\n    else {\r\n        chainId = \"Unknown-0-\" + _chainId++;\r\n    }\r\n    var proxyChain = {\r\n        getPlugin: function () {\r\n            return plugin;\r\n        },\r\n        getNext: function () {\r\n            return nextProxy;\r\n        },\r\n        processTelemetry: _processTelemetry,\r\n        unload: _unloadPlugin,\r\n        update: _updatePlugin,\r\n        _id: chainId,\r\n        _setNext: function (nextPlugin) {\r\n            nextProxy = nextPlugin;\r\n        }\r\n    };\r\n    function _getTelCtx() {\r\n        var itemCtx;\r\n        // Looks like a plugin didn't pass the (optional) context, so create a new one\r\n        if (plugin && isFunction(plugin[strGetTelCtx])) {\r\n            // This plugin extends from the BaseTelemetryPlugin so lets use it\r\n            itemCtx = plugin[strGetTelCtx]();\r\n        }\r\n        if (!itemCtx) {\r\n            // Create a temporary one\r\n            itemCtx = createProcessTelemetryContext(proxyChain, config, core);\r\n        }\r\n        return itemCtx;\r\n    }\r\n    function _processChain(itemCtx, processPluginFn, name, details, isAsync) {\r\n        var hasRun = false;\r\n        var identifier = plugin ? plugin[_DYN_IDENTIFIER /* @min:%2eidentifier */] : strTelemetryPluginChain;\r\n        var hasRunContext = itemCtx[strHasRunFlags];\r\n        if (!hasRunContext) {\r\n            // Assign and populate\r\n            hasRunContext = itemCtx[strHasRunFlags] = {};\r\n        }\r\n        // Ensure that we keep the context in sync\r\n        itemCtx.setNext(nextProxy);\r\n        if (plugin) {\r\n            doPerf(itemCtx[STR_CORE /* @min:%2ecore */](), function () { return identifier + \":\" + name; }, function () {\r\n                // Mark this component as having run\r\n                hasRunContext[chainId] = true;\r\n                try {\r\n                    // Set a flag on the next plugin so we know if it was attempted to be executed\r\n                    var nextId = nextProxy ? nextProxy._id : STR_EMPTY;\r\n                    if (nextId) {\r\n                        hasRunContext[nextId] = false;\r\n                    }\r\n                    hasRun = processPluginFn(itemCtx);\r\n                }\r\n                catch (error) {\r\n                    var hasNextRun = nextProxy ? hasRunContext[nextProxy._id] : true;\r\n                    if (hasNextRun) {\r\n                        // The next plugin after us has already run so set this one as complete\r\n                        hasRun = true;\r\n                    }\r\n                    if (!nextProxy || !hasNextRun) {\r\n                        // Either we have no next plugin or the current one did not attempt to call the next plugin\r\n                        // Which means the current one is the root of the failure so log/report this failure\r\n                        _throwInternal(itemCtx[_DYN_DIAG_LOG /* @min:%2ediagLog */](), 1 /* eLoggingSeverity.CRITICAL */, 73 /* _eInternalMessageId.PluginException */, \"Plugin [\" + identifier + \"] failed during \" + name + \" - \" + dumpObj(error) + \", run flags: \" + dumpObj(hasRunContext));\r\n                    }\r\n                }\r\n            }, details, isAsync);\r\n        }\r\n        return hasRun;\r\n    }\r\n    function _processTelemetry(env, itemCtx) {\r\n        itemCtx = itemCtx || _getTelCtx();\r\n        function _callProcessTelemetry(itemCtx) {\r\n            if (!plugin || !hasProcessTelemetry) {\r\n                return false;\r\n            }\r\n            var pluginState = _getPluginState(plugin);\r\n            if (pluginState[_DYN_TEARDOWN /* @min:%2eteardown */] || pluginState[STR_DISABLED]) {\r\n                return false;\r\n            }\r\n            // Ensure that we keep the context in sync (for processNext()), just in case a plugin\r\n            // doesn't calls processTelemetry() instead of itemContext.processNext() or some\r\n            // other form of error occurred\r\n            if (hasSetNext) {\r\n                // Backward compatibility setting the next plugin on the instance\r\n                plugin[_DYN_SET_NEXT_PLUGIN /* @min:%2esetNextPlugin */](nextProxy);\r\n            }\r\n            plugin[STR_PROCESS_TELEMETRY /* @min:%2eprocessTelemetry */](env, itemCtx);\r\n            // Process Telemetry is expected to call itemCtx.processNext() or nextPlugin.processTelemetry()\r\n            return true;\r\n        }\r\n        if (!_processChain(itemCtx, _callProcessTelemetry, \"processTelemetry\", function () { return ({ item: env }); }, !(env.sync))) {\r\n            // The underlying plugin is either not defined, not enabled or does not have a processTelemetry implementation\r\n            // so we still want the next plugin to be executed.\r\n            itemCtx[_DYN_PROCESS_NEXT /* @min:%2eprocessNext */](env);\r\n        }\r\n    }\r\n    function _unloadPlugin(unloadCtx, unloadState) {\r\n        function _callTeardown() {\r\n            // Setting default of hasRun as false so the proxyProcessFn() is called as teardown() doesn't have to exist or call unloadNext().\r\n            var hasRun = false;\r\n            if (plugin) {\r\n                var pluginState = _getPluginState(plugin);\r\n                var pluginCore = plugin[STR_CORE] || pluginState[STR_CORE /* @min:%2ecore */];\r\n                // Only teardown the plugin if it was initialized by the current core (i.e. It's not a shared plugin)\r\n                if (plugin && (!pluginCore || pluginCore === unloadCtx.core()) && !pluginState[_DYN_TEARDOWN /* @min:%2eteardown */]) {\r\n                    // Handle plugins that don't extend from the BaseTelemetryPlugin\r\n                    pluginState[STR_CORE /* @min:%2ecore */] = null;\r\n                    pluginState[_DYN_TEARDOWN /* @min:%2eteardown */] = true;\r\n                    pluginState[_DYN_IS_INITIALIZED /* @min:%2eisInitialized */] = false;\r\n                    if (plugin[_DYN_TEARDOWN /* @min:%2eteardown */] && plugin[_DYN_TEARDOWN /* @min:%2eteardown */](unloadCtx, unloadState) === true) {\r\n                        // plugin told us that it was going to (or has) call unloadCtx.processNext()\r\n                        hasRun = true;\r\n                    }\r\n                }\r\n            }\r\n            return hasRun;\r\n        }\r\n        if (!_processChain(unloadCtx, _callTeardown, \"unload\", function () { }, unloadState[_DYN_IS_ASYNC /* @min:%2eisAsync */])) {\r\n            // Only called if we hasRun was not true\r\n            unloadCtx[_DYN_PROCESS_NEXT /* @min:%2eprocessNext */](unloadState);\r\n        }\r\n    }\r\n    function _updatePlugin(updateCtx, updateState) {\r\n        function _callUpdate() {\r\n            // Setting default of hasRun as false so the proxyProcessFn() is called as teardown() doesn't have to exist or call unloadNext().\r\n            var hasRun = false;\r\n            if (plugin) {\r\n                var pluginState = _getPluginState(plugin);\r\n                var pluginCore = plugin[STR_CORE] || pluginState[STR_CORE /* @min:%2ecore */];\r\n                // Only update the plugin if it was initialized by the current core (i.e. It's not a shared plugin)\r\n                if (plugin && (!pluginCore || pluginCore === updateCtx.core()) && !pluginState[_DYN_TEARDOWN /* @min:%2eteardown */]) {\r\n                    if (plugin[_DYN_UPDATE /* @min:%2eupdate */] && plugin[_DYN_UPDATE /* @min:%2eupdate */](updateCtx, updateState) === true) {\r\n                        // plugin told us that it was going to (or has) call unloadCtx.processNext()\r\n                        hasRun = true;\r\n                    }\r\n                }\r\n            }\r\n            return hasRun;\r\n        }\r\n        if (!_processChain(updateCtx, _callUpdate, \"update\", function () { }, false)) {\r\n            // Only called if we hasRun was not true\r\n            updateCtx[_DYN_PROCESS_NEXT /* @min:%2eprocessNext */](updateState);\r\n        }\r\n    }\r\n    return objFreeze(proxyChain);\r\n}\r\n/**\r\n * This class will be removed!\r\n * @deprecated use createProcessTelemetryContext() instead\r\n */\r\nvar ProcessTelemetryContext = /** @class */ (function () {\r\n    /**\r\n     * Creates a new Telemetry Item context with the current config, core and plugin execution chain\r\n     * @param plugins - The plugin instances that will be executed\r\n     * @param config - The current config\r\n     * @param core - The current core instance\r\n     */\r\n    function ProcessTelemetryContext(pluginChain, config, core, startAt) {\r\n        var _self = this;\r\n        var context = createProcessTelemetryContext(pluginChain, config, core, startAt);\r\n        // Proxy all functions of the context to this object\r\n        proxyFunctions(_self, context, objKeys(context));\r\n    }\r\n    return ProcessTelemetryContext;\r\n}());\r\nexport { ProcessTelemetryContext };\r\n//# sourceMappingURL=ProcessTelemetryContext.js.map","// Copyright (c) Microsoft Corporation. All rights reserved.\r\n// Licensed under the MIT License.\r\n\"use strict\";\r\nvar _a;\r\nimport dynamicProto from \"@microsoft/dynamicproto-js\";\r\nimport { isFunction, objDefine } from \"@nevware21/ts-utils\";\r\nimport { createDynamicConfig } from \"../Config/DynamicConfig\";\r\nimport { _DYN_CREATE_NEW, _DYN_DIAG_LOG, _DYN_GET_NEXT, _DYN_GET_PROCESS_TEL_CONT0, _DYN_INITIALIZE, _DYN_IS_ASYNC, _DYN_IS_INITIALIZED, _DYN_PROCESS_NEXT, _DYN_SET_NEXT_PLUGIN, _DYN_TEARDOWN, _DYN_UPDATE, _DYN__DO_TEARDOWN } from \"../__DynamicConstants\";\r\nimport { safeGetLogger } from \"./DiagnosticLogger\";\r\nimport { isNotNullOrUndefined, proxyFunctionAs } from \"./HelperFuncs\";\r\nimport { STR_CORE, STR_EXTENSION_CONFIG, STR_PROCESS_TELEMETRY } from \"./InternalConstants\";\r\nimport { createProcessTelemetryContext, createProcessTelemetryUnloadContext, createProcessTelemetryUpdateContext } from \"./ProcessTelemetryContext\";\r\nimport { createUnloadHandlerContainer } from \"./UnloadHandlerContainer\";\r\nimport { createUnloadHookContainer } from \"./UnloadHookContainer\";\r\nvar strGetPlugin = \"getPlugin\";\r\nvar defaultValues = (_a = {},\r\n    _a[STR_EXTENSION_CONFIG] = { isVal: isNotNullOrUndefined, v: {} },\r\n    _a);\r\n/**\r\n * BaseTelemetryPlugin provides a basic implementation of the ITelemetryPlugin interface so that plugins\r\n * can avoid implementation the same set of boiler plate code as well as provide a base\r\n * implementation so that new default implementations can be added without breaking all plugins.\r\n */\r\nvar BaseTelemetryPlugin = /** @class */ (function () {\r\n    function BaseTelemetryPlugin() {\r\n        var _self = this; // Setting _self here as it's used outside of the dynamicProto as well\r\n        // NOTE!: DON'T set default values here, instead set them in the _initDefaults() function as it is also called during teardown()\r\n        var _isinitialized;\r\n        var _rootCtx; // Used as the root context, holding the current config and initialized core\r\n        var _nextPlugin; // Used for backward compatibility where plugins don't call the main pipeline\r\n        var _unloadHandlerContainer;\r\n        var _hookContainer;\r\n        _initDefaults();\r\n        dynamicProto(BaseTelemetryPlugin, _self, function (_self) {\r\n            _self[_DYN_INITIALIZE /* @min:%2einitialize */] = function (config, core, extensions, pluginChain) {\r\n                _setDefaults(config, core, pluginChain);\r\n                _isinitialized = true;\r\n            };\r\n            _self[_DYN_TEARDOWN /* @min:%2eteardown */] = function (unloadCtx, unloadState) {\r\n                var _a;\r\n                // If this plugin has already been torn down (not operational) or is not initialized (core is not set)\r\n                // or the core being used for unload was not the same core used for initialization.\r\n                var core = _self[STR_CORE /* @min:%2ecore */];\r\n                if (!core || (unloadCtx && core !== unloadCtx[STR_CORE /* @min:%2ecore */]())) {\r\n                    // Do Nothing as either the plugin is not initialized or was not initialized by the current core\r\n                    return;\r\n                }\r\n                var result;\r\n                var unloadDone = false;\r\n                var theUnloadCtx = unloadCtx || createProcessTelemetryUnloadContext(null, core, _nextPlugin && _nextPlugin[strGetPlugin] ? _nextPlugin[strGetPlugin]() : _nextPlugin);\r\n                var theUnloadState = unloadState || (_a = {\r\n                        reason: 0 /* TelemetryUnloadReason.ManualTeardown */\r\n                    },\r\n                    _a[_DYN_IS_ASYNC /* @min:isAsync */] = false,\r\n                    _a);\r\n                function _unloadCallback() {\r\n                    if (!unloadDone) {\r\n                        unloadDone = true;\r\n                        _unloadHandlerContainer.run(theUnloadCtx, unloadState);\r\n                        _hookContainer.run(theUnloadCtx[_DYN_DIAG_LOG /* @min:%2ediagLog */]());\r\n                        if (result === true) {\r\n                            theUnloadCtx[_DYN_PROCESS_NEXT /* @min:%2eprocessNext */](theUnloadState);\r\n                        }\r\n                        _initDefaults();\r\n                    }\r\n                }\r\n                if (!_self[_DYN__DO_TEARDOWN /* @min:%2e_doTeardown */] || _self[_DYN__DO_TEARDOWN /* @min:%2e_doTeardown */](theUnloadCtx, theUnloadState, _unloadCallback) !== true) {\r\n                    _unloadCallback();\r\n                }\r\n                else {\r\n                    // Tell the caller that we will be calling processNext()\r\n                    result = true;\r\n                }\r\n                return result;\r\n            };\r\n            _self[_DYN_UPDATE /* @min:%2eupdate */] = function (updateCtx, updateState) {\r\n                // If this plugin has already been torn down (not operational) or is not initialized (core is not set)\r\n                // or the core being used for unload was not the same core used for initialization.\r\n                var core = _self[STR_CORE /* @min:%2ecore */];\r\n                if (!core || (updateCtx && core !== updateCtx[STR_CORE /* @min:%2ecore */]())) {\r\n                    // Do Nothing\r\n                    return;\r\n                }\r\n                var result;\r\n                var updateDone = false;\r\n                var theUpdateCtx = updateCtx || createProcessTelemetryUpdateContext(null, core, _nextPlugin && _nextPlugin[strGetPlugin] ? _nextPlugin[strGetPlugin]() : _nextPlugin);\r\n                var theUpdateState = updateState || {\r\n                    reason: 0 /* TelemetryUpdateReason.Unknown */\r\n                };\r\n                function _updateCallback() {\r\n                    if (!updateDone) {\r\n                        updateDone = true;\r\n                        _setDefaults(theUpdateCtx.getCfg(), theUpdateCtx.core(), theUpdateCtx[_DYN_GET_NEXT /* @min:%2egetNext */]());\r\n                    }\r\n                }\r\n                if (!_self._doUpdate || _self._doUpdate(theUpdateCtx, theUpdateState, _updateCallback) !== true) {\r\n                    _updateCallback();\r\n                }\r\n                else {\r\n                    result = true;\r\n                }\r\n                return result;\r\n            };\r\n            proxyFunctionAs(_self, \"_addUnloadCb\", function () { return _unloadHandlerContainer; }, \"add\");\r\n            proxyFunctionAs(_self, \"_addHook\", function () { return _hookContainer; }, \"add\");\r\n            objDefine(_self, \"_unloadHooks\", { g: function () { return _hookContainer; } });\r\n        });\r\n        // These are added after the dynamicProto so that are not moved to the prototype\r\n        _self[_DYN_DIAG_LOG /* @min:%2ediagLog */] = function (itemCtx) {\r\n            return _getTelCtx(itemCtx)[_DYN_DIAG_LOG /* @min:%2ediagLog */]();\r\n        };\r\n        _self[_DYN_IS_INITIALIZED /* @min:%2eisInitialized */] = function () {\r\n            return _isinitialized;\r\n        };\r\n        _self.setInitialized = function (isInitialized) {\r\n            _isinitialized = isInitialized;\r\n        };\r\n        // _self.getNextPlugin = () => DO NOT IMPLEMENT\r\n        // Sub-classes of this base class *should* not be relying on this value and instead\r\n        // should use processNext() function. If you require access to the plugin use the\r\n        // IProcessTelemetryContext.getNext().getPlugin() while in the pipeline, Note getNext() may return null.\r\n        _self[_DYN_SET_NEXT_PLUGIN /* @min:%2esetNextPlugin */] = function (next) {\r\n            _nextPlugin = next;\r\n        };\r\n        _self[_DYN_PROCESS_NEXT /* @min:%2eprocessNext */] = function (env, itemCtx) {\r\n            if (itemCtx) {\r\n                // Normal core execution sequence\r\n                itemCtx[_DYN_PROCESS_NEXT /* @min:%2eprocessNext */](env);\r\n            }\r\n            else if (_nextPlugin && isFunction(_nextPlugin[STR_PROCESS_TELEMETRY /* @min:%2eprocessTelemetry */])) {\r\n                // Looks like backward compatibility or out of band processing. And as it looks\r\n                // like a ITelemetryPlugin or ITelemetryPluginChain, just call processTelemetry\r\n                _nextPlugin[STR_PROCESS_TELEMETRY /* @min:%2eprocessTelemetry */](env, null);\r\n            }\r\n        };\r\n        _self._getTelCtx = _getTelCtx;\r\n        function _getTelCtx(currentCtx) {\r\n            if (currentCtx === void 0) { currentCtx = null; }\r\n            var itemCtx = currentCtx;\r\n            if (!itemCtx) {\r\n                var rootCtx = _rootCtx || createProcessTelemetryContext(null, {}, _self[STR_CORE /* @min:%2ecore */]);\r\n                // tslint:disable-next-line: prefer-conditional-expression\r\n                if (_nextPlugin && _nextPlugin[strGetPlugin]) {\r\n                    // Looks like a chain object\r\n                    itemCtx = rootCtx[_DYN_CREATE_NEW /* @min:%2ecreateNew */](null, _nextPlugin[strGetPlugin]);\r\n                }\r\n                else {\r\n                    itemCtx = rootCtx[_DYN_CREATE_NEW /* @min:%2ecreateNew */](null, _nextPlugin);\r\n                }\r\n            }\r\n            return itemCtx;\r\n        }\r\n        function _setDefaults(config, core, pluginChain) {\r\n            // Make sure the extensionConfig exists and the config is dynamic\r\n            createDynamicConfig(config, defaultValues, safeGetLogger(core));\r\n            if (!pluginChain && core) {\r\n                // Get the first plugin from the core\r\n                pluginChain = core[_DYN_GET_PROCESS_TEL_CONT0 /* @min:%2egetProcessTelContext */]()[_DYN_GET_NEXT /* @min:%2egetNext */]();\r\n            }\r\n            var nextPlugin = _nextPlugin;\r\n            if (_nextPlugin && _nextPlugin[strGetPlugin]) {\r\n                // If it looks like a proxy/chain then get the plugin\r\n                nextPlugin = _nextPlugin[strGetPlugin]();\r\n            }\r\n            // Support legacy plugins where core was defined as a property\r\n            _self[STR_CORE /* @min:%2ecore */] = core;\r\n            _rootCtx = createProcessTelemetryContext(pluginChain, config, core, nextPlugin);\r\n        }\r\n        function _initDefaults() {\r\n            _isinitialized = false;\r\n            _self[STR_CORE /* @min:%2ecore */] = null;\r\n            _rootCtx = null;\r\n            _nextPlugin = null;\r\n            _hookContainer = createUnloadHookContainer();\r\n            _unloadHandlerContainer = createUnloadHandlerContainer();\r\n        }\r\n    }\r\n    BaseTelemetryPlugin.prototype.initialize = function (config, core, extensions, pluginChain) {\r\n        // @DynamicProtoStub -- DO NOT add any code as this will be removed during packaging\r\n    };\r\n    /**\r\n     * Tear down the plugin and remove any hooked value, the plugin should be removed so that it is no longer initialized and\r\n     * therefore could be re-initialized after being torn down. The plugin should ensure that once this has been called any further\r\n     * processTelemetry calls are ignored and it just calls the processNext() with the provided context.\r\n     * @param unloadCtx - This is the context that should be used during unloading.\r\n     * @param unloadState - The details / state of the unload process, it holds details like whether it should be unloaded synchronously or asynchronously and the reason for the unload.\r\n     * @returns boolean - true if the plugin has or will call processNext(), this for backward compatibility as previously teardown was synchronous and returned nothing.\r\n     */\r\n    BaseTelemetryPlugin.prototype.teardown = function (unloadCtx, unloadState) {\r\n        // @DynamicProtoStub -- DO NOT add any code as this will be removed during packaging\r\n        return false;\r\n    };\r\n    /**\r\n     * The the plugin should re-evaluate configuration and update any cached configuration settings.\r\n     * @param updateCtx - This is the context that should be used during updating.\r\n     * @param updateState - The details / state of the update process, it holds details like the current and previous configuration.\r\n     * @returns boolean - true if the plugin has or will call updateCtx.processNext(), this allows the plugin to perform any asynchronous operations.\r\n     */\r\n    BaseTelemetryPlugin.prototype.update = function (updateCtx, updateState) {\r\n        // @DynamicProtoStub -- DO NOT add any code as this will be removed during packaging\r\n    };\r\n    /**\r\n     * Add an unload handler that will be called when the SDK is being unloaded\r\n     * @param handler - the handler\r\n     */\r\n    BaseTelemetryPlugin.prototype._addUnloadCb = function (handler) {\r\n        // @DynamicProtoStub -- DO NOT add any code as this will be removed during packaging\r\n    };\r\n    /**\r\n     * Add this hook so that it is automatically removed during unloading\r\n     * @param hooks - The single hook or an array of IInstrumentHook objects\r\n     */\r\n    BaseTelemetryPlugin.prototype._addHook = function (hooks) {\r\n        // @DynamicProtoStub -- DO NOT add any code as this will be removed during packaging\r\n    };\r\n    return BaseTelemetryPlugin;\r\n}());\r\nexport { BaseTelemetryPlugin };\r\n//# sourceMappingURL=BaseTelemetryPlugin.js.map","// Copyright (c) Microsoft Corporation. All rights reserved.\r\n// Licensed under the MIT License.\r\nimport { arrForEach, dumpObj } from \"@nevware21/ts-utils\";\r\nimport { _DYN_DIAG_LOG, _DYN_PUSH } from \"../__DynamicConstants\";\r\nimport { _throwInternal } from \"./DiagnosticLogger\";\r\nexport function createUnloadHandlerContainer() {\r\n    var handlers = [];\r\n    function _addHandler(handler) {\r\n        if (handler) {\r\n            handlers[_DYN_PUSH /* @min:%2epush */](handler);\r\n        }\r\n    }\r\n    function _runHandlers(unloadCtx, unloadState) {\r\n        arrForEach(handlers, function (handler) {\r\n            try {\r\n                handler(unloadCtx, unloadState);\r\n            }\r\n            catch (e) {\r\n                _throwInternal(unloadCtx[_DYN_DIAG_LOG /* @min:%2ediagLog */](), 2 /* eLoggingSeverity.WARNING */, 73 /* _eInternalMessageId.PluginException */, \"Unexpected error calling unload handler - \" + dumpObj(e));\r\n            }\r\n        });\r\n        handlers = [];\r\n    }\r\n    return {\r\n        add: _addHandler,\r\n        run: _runHandlers\r\n    };\r\n}\r\n//# sourceMappingURL=UnloadHandlerContainer.js.map","// Copyright (c) Microsoft Corporation. All rights reserved.\r\n// Licensed under the MIT License.\r\nimport { arrAppend, arrForEach, dumpObj } from \"@nevware21/ts-utils\";\r\nimport { _throwInternal } from \"./DiagnosticLogger\";\r\n/**\r\n * Create a IUnloadHookContainer which can be used to remember unload hook functions to be executed during the component unloading\r\n * process.\r\n * @returns A new IUnloadHookContainer instance\r\n */\r\nexport function createUnloadHookContainer() {\r\n    var _hooks = [];\r\n    function _doUnload(logger) {\r\n        var oldHooks = _hooks;\r\n        _hooks = [];\r\n        // Remove all registered unload hooks\r\n        arrForEach(oldHooks, function (fn) {\r\n            // allow either rm or remove callback function\r\n            try {\r\n                (fn.rm || fn.remove).call(fn);\r\n            }\r\n            catch (e) {\r\n                _throwInternal(logger, 2 /* eLoggingSeverity.WARNING */, 73 /* _eInternalMessageId.PluginException */, \"Unloading:\" + dumpObj(e));\r\n            }\r\n        });\r\n    }\r\n    function _addHook(hooks) {\r\n        if (hooks) {\r\n            arrAppend(_hooks, hooks);\r\n        }\r\n    }\r\n    return {\r\n        run: _doUnload,\r\n        add: _addHook\r\n    };\r\n}\r\n//# sourceMappingURL=UnloadHookContainer.js.map","// // Copyright (c) Microsoft Corporation. All rights reserved.\r\n// // Licensed under the MIT License.\r\nimport { __extends } from \"tslib\";\r\nimport dynamicProto from \"@microsoft/dynamicproto-js\";\r\nimport { arrAppend, arrForEach, dumpObj } from \"@nevware21/ts-utils\";\r\nimport { _DYN_APPLY, _DYN_DIAG_LOG, _DYN_LENGTH, _DYN_PROCESS_NEXT, _DYN_SPLICE, _DYN__DO_TEARDOWN } from \"../__DynamicConstants\";\r\nimport { BaseTelemetryPlugin } from \"./BaseTelemetryPlugin\";\r\nimport { _throwInternal } from \"./DiagnosticLogger\";\r\nimport { getExceptionName } from \"./HelperFuncs\";\r\nimport { STR_PROCESS_TELEMETRY } from \"./InternalConstants\";\r\nfunction _addInitializer(_initializers, id, telemetryInitializer) {\r\n    var theInitializer = {\r\n        id: id,\r\n        fn: telemetryInitializer\r\n    };\r\n    arrAppend(_initializers, theInitializer);\r\n    var handler = {\r\n        remove: function () {\r\n            arrForEach(_initializers, function (initializer, idx) {\r\n                if (initializer.id === theInitializer.id) {\r\n                    _initializers[_DYN_SPLICE /* @min:%2esplice */](idx, 1);\r\n                    return -1;\r\n                }\r\n            });\r\n        }\r\n    };\r\n    return handler;\r\n}\r\nfunction _runInitializers(_initializers, item, logger) {\r\n    var doNotSendItem = false;\r\n    var telemetryInitializersCount = _initializers[_DYN_LENGTH /* @min:%2elength */];\r\n    for (var i = 0; i < telemetryInitializersCount; ++i) {\r\n        var telemetryInitializer = _initializers[i];\r\n        if (telemetryInitializer) {\r\n            try {\r\n                if (telemetryInitializer.fn[_DYN_APPLY /* @min:%2eapply */](null, [item]) === false) {\r\n                    doNotSendItem = true;\r\n                    break;\r\n                }\r\n            }\r\n            catch (e) {\r\n                // log error but dont stop executing rest of the telemetry initializers\r\n                // doNotSendItem = true;\r\n                _throwInternal(logger, 2 /* eLoggingSeverity.WARNING */, 64 /* _eInternalMessageId.TelemetryInitializerFailed */, \"Telemetry initializer failed: \" + getExceptionName(e), { exception: dumpObj(e) }, true);\r\n            }\r\n        }\r\n    }\r\n    return !doNotSendItem;\r\n}\r\nvar TelemetryInitializerPlugin = /** @class */ (function (_super) {\r\n    __extends(TelemetryInitializerPlugin, _super);\r\n    function TelemetryInitializerPlugin() {\r\n        var _this = _super.call(this) || this;\r\n        _this.identifier = \"TelemetryInitializerPlugin\";\r\n        _this.priority = 199;\r\n        // NOTE!: DON'T set default values here, instead set them in the _initDefaults() function as it is also called during teardown()\r\n        var _id;\r\n        var _initializers;\r\n        _initDefaults();\r\n        dynamicProto(TelemetryInitializerPlugin, _this, function (_self, _base) {\r\n            _self.addTelemetryInitializer = function (telemetryInitializer) {\r\n                return _addInitializer(_initializers, _id++, telemetryInitializer);\r\n            };\r\n            _self[STR_PROCESS_TELEMETRY /* @min:%2eprocessTelemetry */] = function (item, itemCtx) {\r\n                if (_runInitializers(_initializers, item, itemCtx ? itemCtx[_DYN_DIAG_LOG /* @min:%2ediagLog */]() : _self[_DYN_DIAG_LOG /* @min:%2ediagLog */]())) {\r\n                    _self[_DYN_PROCESS_NEXT /* @min:%2eprocessNext */](item, itemCtx);\r\n                }\r\n            };\r\n            _self[_DYN__DO_TEARDOWN /* @min:%2e_doTeardown */] = function () {\r\n                _initDefaults();\r\n            };\r\n        });\r\n        function _initDefaults() {\r\n            _id = 0;\r\n            _initializers = [];\r\n        }\r\n        return _this;\r\n    }\r\n    /**\r\n     * Add a telemetry processor to decorate or drop telemetry events.\r\n     * @param telemetryInitializer - The Telemetry Initializer function\r\n     * @returns - A ITelemetryInitializerHandler to enable the initializer to be removed\r\n     */\r\n    TelemetryInitializerPlugin.prototype.addTelemetryInitializer = function (telemetryInitializer) {\r\n        // @DynamicProtoStub -- DO NOT add any code as this will be removed during packaging\r\n        return null;\r\n    };\r\n    TelemetryInitializerPlugin.prototype.processTelemetry = function (env, itemCtx) {\r\n        // @DynamicProtoStub -- DO NOT add any code as this will be removed during packaging\r\n    };\r\n    return TelemetryInitializerPlugin;\r\n}(BaseTelemetryPlugin));\r\nexport { TelemetryInitializerPlugin };\r\n//# sourceMappingURL=TelemetryInitializerPlugin.js.map","// Copyright (c) Microsoft Corporation. All rights reserved.\r\n// Licensed under the MIT License.\r\n\"use strict\";\r\nvar _a;\r\nimport { __spreadArray } from \"tslib\";\r\nimport dynamicProto from \"@microsoft/dynamicproto-js\";\r\nimport { createPromise } from \"@nevware21/ts-async\";\r\nimport { arrAppend, arrForEach, arrIndexOf, createTimeout, deepExtend, hasDocument, isFunction, isNullOrUndefined, isPlainObject, objDeepFreeze, objDefine, objForEachKey, objFreeze, objHasOwn, scheduleTimeout, throwError } from \"@nevware21/ts-utils\";\r\nimport { createDynamicConfig, onConfigChange } from \"../Config/DynamicConfig\";\r\nimport { _DYN_ADD_NOTIFICATION_LIS1, _DYN_CANCEL, _DYN_CREATE_NEW, _DYN_ENABLED, _DYN_GET_NOTIFY_MGR, _DYN_GET_PLUGIN, _DYN_GET_PROCESS_TEL_CONT0, _DYN_IDENTIFIER, _DYN_INITIALIZE, _DYN_IS_ASYNC, _DYN_IS_INITIALIZED, _DYN_LENGTH, _DYN_LOGGER, _DYN_LOGGING_LEVEL_CONSOL4, _DYN_MESSAGE, _DYN_MESSAGE_ID, _DYN_NAME, _DYN_NOTIFY, _DYN_ON_COMPLETE, _DYN_POLL_INTERNAL_LOGS, _DYN_PROCESS_NEXT, _DYN_PUSH, _DYN_REMOVE_NOTIFICATION_2, _DYN_SET_DF, _DYN_SPLICE, _DYN_STOP_POLLING_INTERNA3, _DYN_TEARDOWN, _DYN_TIME, _DYN_UNLOAD, _DYN_VERSION, _DYN_WATCH } from \"../__DynamicConstants\";\r\nimport { doUnloadAll, runTargetUnload } from \"./AsyncUtils\";\r\nimport { ChannelControllerPriority } from \"./Constants\";\r\nimport { createCookieMgr } from \"./CookieMgr\";\r\nimport { createUniqueNamespace } from \"./DataCacheHelper\";\r\nimport { getDebugListener } from \"./DbgExtensionUtils\";\r\nimport { DiagnosticLogger, _InternalLogMessage, _throwInternal, _warnToConsole } from \"./DiagnosticLogger\";\r\nimport { getSetValue, proxyFunctionAs, proxyFunctions, toISOString } from \"./HelperFuncs\";\r\nimport { STR_CHANNELS, STR_CORE, STR_CREATE_PERF_MGR, STR_DISABLED, STR_EMPTY, STR_EVENTS_DISCARDED, STR_EXTENSIONS, STR_EXTENSION_CONFIG, STR_GET_PERF_MGR, STR_PRIORITY, UNDEFINED_VALUE } from \"./InternalConstants\";\r\nimport { NotificationManager } from \"./NotificationManager\";\r\nimport { PerfManager, doPerf, getGblPerfMgr } from \"./PerfManager\";\r\nimport { createProcessTelemetryContext, createProcessTelemetryUnloadContext, createProcessTelemetryUpdateContext, createTelemetryProxyChain } from \"./ProcessTelemetryContext\";\r\nimport { _getPluginState, createDistributedTraceContext, initializePlugins, sortPlugins } from \"./TelemetryHelpers\";\r\nimport { TelemetryInitializerPlugin } from \"./TelemetryInitializerPlugin\";\r\nimport { createUnloadHandlerContainer } from \"./UnloadHandlerContainer\";\r\nimport { createUnloadHookContainer } from \"./UnloadHookContainer\";\r\nvar strValidationError = \"Plugins must provide initialize method\";\r\nvar strNotificationManager = \"_notificationManager\";\r\nvar strSdkUnloadingError = \"SDK is still unloading...\";\r\nvar strSdkNotInitialized = \"SDK is not initialized\";\r\n// const strPluginUnloadFailed = \"Failed to unload plugin\";\r\n/**\r\n * The default settings for the config.\r\n * WE MUST include all defaults here to ensure that the config is created with all of the properties\r\n * defined as dynamic.\r\n */\r\nvar defaultConfig = objDeepFreeze((_a = {\r\n        cookieCfg: {}\r\n    },\r\n    _a[STR_EXTENSIONS] = { rdOnly: true, ref: true, v: [] },\r\n    _a[STR_CHANNELS] = { rdOnly: true, ref: true, v: [] },\r\n    _a[STR_EXTENSION_CONFIG] = { ref: true, v: {} },\r\n    _a[STR_CREATE_PERF_MGR] = UNDEFINED_VALUE,\r\n    _a.loggingLevelConsole = 0 /* eLoggingSeverity.DISABLED */,\r\n    _a.diagnosticLogInterval = UNDEFINED_VALUE,\r\n    _a));\r\n/**\r\n * Helper to create the default performance manager\r\n * @param core\r\n * @param notificationMgr\r\n */\r\nfunction _createPerfManager(core, notificationMgr) {\r\n    return new PerfManager(notificationMgr);\r\n}\r\nfunction _validateExtensions(logger, channelPriority, allExtensions) {\r\n    var _a;\r\n    // Concat all available extensions\r\n    var coreExtensions = [];\r\n    var channels = [];\r\n    // Check if any two extensions have the same priority, then warn to console\r\n    // And extract the local extensions from the\r\n    var extPriorities = {};\r\n    // Extension validation\r\n    arrForEach(allExtensions, function (ext) {\r\n        // Check for ext.initialize\r\n        if (isNullOrUndefined(ext) || isNullOrUndefined(ext[_DYN_INITIALIZE /* @min:%2einitialize */])) {\r\n            throwError(strValidationError);\r\n        }\r\n        var extPriority = ext[STR_PRIORITY /* @min:%2epriority */];\r\n        var identifier = ext[_DYN_IDENTIFIER /* @min:%2eidentifier */];\r\n        if (ext && extPriority) {\r\n            if (!isNullOrUndefined(extPriorities[extPriority])) {\r\n                _warnToConsole(logger, \"Two extensions have same priority #\" + extPriority + \" - \" + extPriorities[extPriority] + \", \" + identifier);\r\n            }\r\n            else {\r\n                // set a value\r\n                extPriorities[extPriority] = identifier;\r\n            }\r\n        }\r\n        // Split extensions to core and channels\r\n        if (!extPriority || extPriority < channelPriority) {\r\n            // Add to core extension that will be managed by AppInsightsCore\r\n            coreExtensions[_DYN_PUSH /* @min:%2epush */](ext);\r\n        }\r\n        else {\r\n            channels[_DYN_PUSH /* @min:%2epush */](ext);\r\n        }\r\n    });\r\n    return _a = {},\r\n        _a[STR_CORE /* @min:core */] = coreExtensions,\r\n        _a[STR_CHANNELS /* @min:channels */] = channels,\r\n        _a;\r\n}\r\nfunction _isPluginPresent(thePlugin, plugins) {\r\n    var exists = false;\r\n    arrForEach(plugins, function (plugin) {\r\n        if (plugin === thePlugin) {\r\n            exists = true;\r\n            return -1;\r\n        }\r\n    });\r\n    return exists;\r\n}\r\nfunction _deepMergeConfig(details, target, newValues, merge) {\r\n    // Lets assign the new values to the existing config\r\n    if (newValues) {\r\n        objForEachKey(newValues, function (key, value) {\r\n            if (merge) {\r\n                if (isPlainObject(value) && isPlainObject(target[key])) {\r\n                    // The target is an object and it has a value\r\n                    _deepMergeConfig(details, target[key], value, merge);\r\n                }\r\n            }\r\n            if (merge && isPlainObject(value) && isPlainObject(target[key])) {\r\n                // The target is an object and it has a value\r\n                _deepMergeConfig(details, target[key], value, merge);\r\n            }\r\n            else {\r\n                // Just Assign (replace) and/or make the property dynamic\r\n                details.set(target, key, value);\r\n            }\r\n        });\r\n    }\r\n}\r\nfunction _findWatcher(listeners, newWatcher) {\r\n    var theListener = null;\r\n    var idx = -1;\r\n    arrForEach(listeners, function (listener, lp) {\r\n        if (listener.w === newWatcher) {\r\n            theListener = listener;\r\n            idx = lp;\r\n            return -1;\r\n        }\r\n    });\r\n    return { i: idx, l: theListener };\r\n}\r\nfunction _addDelayedCfgListener(listeners, newWatcher) {\r\n    var theListener = _findWatcher(listeners, newWatcher).l;\r\n    if (!theListener) {\r\n        theListener = {\r\n            w: newWatcher,\r\n            rm: function () {\r\n                var fnd = _findWatcher(listeners, newWatcher);\r\n                if (fnd.i !== -1) {\r\n                    listeners[_DYN_SPLICE /* @min:%2esplice */](fnd.i, 1);\r\n                }\r\n            }\r\n        };\r\n        listeners[_DYN_PUSH /* @min:%2epush */](theListener);\r\n    }\r\n    return theListener;\r\n}\r\nfunction _registerDelayedCfgListener(config, listeners, logger) {\r\n    arrForEach(listeners, function (listener) {\r\n        var unloadHdl = onConfigChange(config, listener.w, logger);\r\n        delete listener.w; // Clear the listener reference so it will get garbage collected.\r\n        // replace the remove function\r\n        listener.rm = function () {\r\n            unloadHdl.rm();\r\n        };\r\n    });\r\n}\r\nvar AppInsightsCore = /** @class */ (function () {\r\n    function AppInsightsCore() {\r\n        // NOTE!: DON'T set default values here, instead set them in the _initDefaults() function as it is also called during teardown()\r\n        var _configHandler;\r\n        var _isInitialized;\r\n        var _logger;\r\n        var _eventQueue;\r\n        var _notificationManager;\r\n        var _perfManager;\r\n        var _cfgPerfManager;\r\n        var _cookieManager;\r\n        var _pluginChain;\r\n        var _configExtensions;\r\n        var _channelConfig;\r\n        var _channels;\r\n        var _isUnloading;\r\n        var _telemetryInitializerPlugin;\r\n        var _internalLogsEventName;\r\n        var _evtNamespace;\r\n        var _unloadHandlers;\r\n        var _hookContainer;\r\n        var _debugListener;\r\n        var _traceCtx;\r\n        var _instrumentationKey;\r\n        var _cfgListeners;\r\n        var _extensions;\r\n        var _pluginVersionStringArr;\r\n        var _pluginVersionString;\r\n        /**\r\n         * Internal log poller\r\n         */\r\n        var _internalLogPoller;\r\n        var _internalLogPollerListening;\r\n        var _forceStopInternalLogPoller;\r\n        dynamicProto(AppInsightsCore, this, function (_self) {\r\n            // Set the default values (also called during teardown)\r\n            _initDefaults();\r\n            // Special internal method to allow the unit tests and DebugPlugin to hook embedded objects\r\n            _self[\"_getDbgPlgTargets\"] = function () {\r\n                return [_extensions];\r\n            };\r\n            _self[_DYN_IS_INITIALIZED /* @min:%2eisInitialized */] = function () { return _isInitialized; };\r\n            // Creating the self.initialize = ()\r\n            _self[_DYN_INITIALIZE /* @min:%2einitialize */] = function (config, extensions, logger, notificationManager) {\r\n                if (_isUnloading) {\r\n                    throwError(strSdkUnloadingError);\r\n                }\r\n                // Make sure core is only initialized once\r\n                if (_self[_DYN_IS_INITIALIZED /* @min:%2eisInitialized */]()) {\r\n                    throwError(\"Core cannot be initialized more than once\");\r\n                }\r\n                _configHandler = createDynamicConfig(config, defaultConfig, logger || _self[_DYN_LOGGER /* @min:%2elogger */], false);\r\n                // Re-assigning the local config property so we don't have any references to the passed value and it can be garbage collected\r\n                config = _configHandler.cfg;\r\n                // This will be \"re-run\" if the referenced config properties are changed\r\n                _addUnloadHook(_configHandler[_DYN_WATCH /* @min:%2ewatch */](function (details) {\r\n                    _instrumentationKey = details.cfg.instrumentationKey;\r\n                    // Mark the extensionConfig and all first level keys as referenced\r\n                    // This is so that calls to getExtCfg() will always return the same object\r\n                    // Even when a user may \"re-assign\" the plugin properties (or it's unloaded/reloaded)\r\n                    var extCfg = details.ref(details.cfg, STR_EXTENSION_CONFIG);\r\n                    objForEachKey(extCfg, function (key) {\r\n                        details.ref(extCfg, key);\r\n                    });\r\n                    if (isNullOrUndefined(_instrumentationKey)) {\r\n                        throwError(\"Please provide instrumentation key\");\r\n                    }\r\n                }));\r\n                _notificationManager = notificationManager;\r\n                _initDebugListener();\r\n                _initPerfManager();\r\n                _self[_DYN_LOGGER /* @min:%2elogger */] = logger;\r\n                var cfgExtensions = config[STR_EXTENSIONS /* @min:%2eextensions */];\r\n                // Extension validation\r\n                _configExtensions = [];\r\n                _configExtensions[_DYN_PUSH /* @min:%2epush */].apply(_configExtensions, __spreadArray(__spreadArray([], extensions, false), cfgExtensions, false));\r\n                _channelConfig = config[STR_CHANNELS /* @min:%2echannels */];\r\n                _initPluginChain(null);\r\n                if (!_channels || _channels[_DYN_LENGTH /* @min:%2elength */] === 0) {\r\n                    throwError(\"No \" + STR_CHANNELS + \" available\");\r\n                }\r\n                if (_channelConfig && _channelConfig[_DYN_LENGTH /* @min:%2elength */] > 1) {\r\n                    var teeController = _self[_DYN_GET_PLUGIN /* @min:%2egetPlugin */](\"TeeChannelController\");\r\n                    if (!teeController || !teeController.plugin) {\r\n                        _throwInternal(_logger, 1 /* eLoggingSeverity.CRITICAL */, 28 /* _eInternalMessageId.SenderNotInitialized */, \"TeeChannel required\");\r\n                    }\r\n                }\r\n                _registerDelayedCfgListener(config, _cfgListeners, _logger);\r\n                _cfgListeners = null;\r\n                _isInitialized = true;\r\n                _self.releaseQueue();\r\n                _self[_DYN_POLL_INTERNAL_LOGS /* @min:%2epollInternalLogs */]();\r\n            };\r\n            _self.getChannels = function () {\r\n                var controls = [];\r\n                if (_channels) {\r\n                    arrForEach(_channels, function (channel) {\r\n                        controls[_DYN_PUSH /* @min:%2epush */](channel);\r\n                    });\r\n                }\r\n                return objFreeze(controls);\r\n            };\r\n            _self.track = function (telemetryItem) {\r\n                doPerf(_self[STR_GET_PERF_MGR /* @min:%2egetPerfMgr */](), function () { return \"AppInsightsCore:track\"; }, function () {\r\n                    if (telemetryItem === null) {\r\n                        _notifyInvalidEvent(telemetryItem);\r\n                        // throw error\r\n                        throwError(\"Invalid telemetry item\");\r\n                    }\r\n                    // do basic validation before sending it through the pipeline\r\n                    if (!telemetryItem[_DYN_NAME /* @min:%2ename */] && isNullOrUndefined(telemetryItem[_DYN_NAME /* @min:%2ename */])) {\r\n                        _notifyInvalidEvent(telemetryItem);\r\n                        throwError(\"telemetry name required\");\r\n                    }\r\n                    // setup default iKey if not passed in\r\n                    telemetryItem.iKey = telemetryItem.iKey || _instrumentationKey;\r\n                    // add default timestamp if not passed in\r\n                    telemetryItem[_DYN_TIME /* @min:%2etime */] = telemetryItem[_DYN_TIME /* @min:%2etime */] || toISOString(new Date());\r\n                    // Common Schema 4.0\r\n                    telemetryItem.ver = telemetryItem.ver || \"4.0\";\r\n                    if (!_isUnloading && _self[_DYN_IS_INITIALIZED /* @min:%2eisInitialized */]()) {\r\n                        // Process the telemetry plugin chain\r\n                        _createTelCtx()[_DYN_PROCESS_NEXT /* @min:%2eprocessNext */](telemetryItem);\r\n                    }\r\n                    else {\r\n                        // Queue events until all extensions are initialized\r\n                        _eventQueue[_DYN_PUSH /* @min:%2epush */](telemetryItem);\r\n                    }\r\n                }, function () { return ({ item: telemetryItem }); }, !(telemetryItem.sync));\r\n            };\r\n            _self[_DYN_GET_PROCESS_TEL_CONT0 /* @min:%2egetProcessTelContext */] = _createTelCtx;\r\n            _self[_DYN_GET_NOTIFY_MGR /* @min:%2egetNotifyMgr */] = function () {\r\n                if (!_notificationManager) {\r\n                    _notificationManager = new NotificationManager(_configHandler.cfg);\r\n                    // For backward compatibility only\r\n                    _self[strNotificationManager] = _notificationManager;\r\n                }\r\n                return _notificationManager;\r\n            };\r\n            /**\r\n             * Adds a notification listener. The SDK calls methods on the listener when an appropriate notification is raised.\r\n             * The added plugins must raise notifications. If the plugins do not implement the notifications, then no methods will be\r\n             * called.\r\n             * @param listener - An INotificationListener object.\r\n             */\r\n            _self[_DYN_ADD_NOTIFICATION_LIS1 /* @min:%2eaddNotificationListener */] = function (listener) {\r\n                _self[_DYN_GET_NOTIFY_MGR /* @min:%2egetNotifyMgr */]()[_DYN_ADD_NOTIFICATION_LIS1 /* @min:%2eaddNotificationListener */](listener);\r\n            };\r\n            /**\r\n             * Removes all instances of the listener.\r\n             * @param listener - INotificationListener to remove.\r\n             */\r\n            _self[_DYN_REMOVE_NOTIFICATION_2 /* @min:%2eremoveNotificationListener */] = function (listener) {\r\n                if (_notificationManager) {\r\n                    _notificationManager[_DYN_REMOVE_NOTIFICATION_2 /* @min:%2eremoveNotificationListener */](listener);\r\n                }\r\n            };\r\n            _self.getCookieMgr = function () {\r\n                if (!_cookieManager) {\r\n                    _cookieManager = createCookieMgr(_configHandler.cfg, _self[_DYN_LOGGER /* @min:%2elogger */]);\r\n                }\r\n                return _cookieManager;\r\n            };\r\n            _self.setCookieMgr = function (cookieMgr) {\r\n                if (_cookieManager !== cookieMgr) {\r\n                    runTargetUnload(_cookieManager, false);\r\n                    _cookieManager = cookieMgr;\r\n                }\r\n            };\r\n            _self[STR_GET_PERF_MGR /* @min:%2egetPerfMgr */] = function () {\r\n                if (!_perfManager && !_cfgPerfManager) {\r\n                    _addUnloadHook(_configHandler[_DYN_WATCH /* @min:%2ewatch */](function (details) {\r\n                        if (details.cfg.enablePerfMgr) {\r\n                            var createPerfMgr = details.cfg[STR_CREATE_PERF_MGR /* @min:%2ecreatePerfMgr */];\r\n                            if (isFunction(createPerfMgr)) {\r\n                                _cfgPerfManager = createPerfMgr(_self, _self[_DYN_GET_NOTIFY_MGR /* @min:%2egetNotifyMgr */]());\r\n                            }\r\n                        }\r\n                    }));\r\n                }\r\n                return _perfManager || _cfgPerfManager || getGblPerfMgr();\r\n            };\r\n            _self.setPerfMgr = function (perfMgr) {\r\n                _perfManager = perfMgr;\r\n            };\r\n            _self.eventCnt = function () {\r\n                return _eventQueue[_DYN_LENGTH /* @min:%2elength */];\r\n            };\r\n            _self.releaseQueue = function () {\r\n                if (_isInitialized && _eventQueue[_DYN_LENGTH /* @min:%2elength */] > 0) {\r\n                    var eventQueue = _eventQueue;\r\n                    _eventQueue = [];\r\n                    arrForEach(eventQueue, function (event) {\r\n                        _createTelCtx()[_DYN_PROCESS_NEXT /* @min:%2eprocessNext */](event);\r\n                    });\r\n                }\r\n            };\r\n            _self[_DYN_POLL_INTERNAL_LOGS /* @min:%2epollInternalLogs */] = function (eventName) {\r\n                _internalLogsEventName = eventName || null;\r\n                _forceStopInternalLogPoller = false;\r\n                _internalLogPoller && _internalLogPoller[_DYN_CANCEL /* @min:%2ecancel */]();\r\n                return _startLogPoller(true);\r\n            };\r\n            function _startLogPoller(alwaysStart) {\r\n                if ((!_internalLogPoller || !_internalLogPoller[_DYN_ENABLED /* @min:%2eenabled */]) && !_forceStopInternalLogPoller) {\r\n                    var shouldStart = alwaysStart || (_logger && _logger.queue[_DYN_LENGTH /* @min:%2elength */] > 0);\r\n                    if (shouldStart) {\r\n                        if (!_internalLogPollerListening) {\r\n                            _internalLogPollerListening = true;\r\n                            // listen for any configuration changes so that changes to the\r\n                            // interval will cause the timer to be re-initialized\r\n                            _addUnloadHook(_configHandler[_DYN_WATCH /* @min:%2ewatch */](function (details) {\r\n                                var interval = details.cfg.diagnosticLogInterval;\r\n                                if (!interval || !(interval > 0)) {\r\n                                    interval = 10000;\r\n                                }\r\n                                var isRunning = false;\r\n                                if (_internalLogPoller) {\r\n                                    // It was already created so remember it's running and cancel\r\n                                    isRunning = _internalLogPoller[_DYN_ENABLED /* @min:%2eenabled */];\r\n                                    _internalLogPoller[_DYN_CANCEL /* @min:%2ecancel */]();\r\n                                }\r\n                                // Create / reconfigure\r\n                                _internalLogPoller = createTimeout(_flushInternalLogs, interval);\r\n                                _internalLogPoller.unref();\r\n                                // Restart if previously running\r\n                                _internalLogPoller[_DYN_ENABLED /* @min:%2eenabled */] = isRunning;\r\n                            }));\r\n                        }\r\n                        _internalLogPoller[_DYN_ENABLED /* @min:%2eenabled */] = true;\r\n                    }\r\n                }\r\n                return _internalLogPoller;\r\n            }\r\n            _self[_DYN_STOP_POLLING_INTERNA3 /* @min:%2estopPollingInternalLogs */] = function () {\r\n                _forceStopInternalLogPoller = true;\r\n                _internalLogPoller && _internalLogPoller[_DYN_CANCEL /* @min:%2ecancel */]();\r\n                _flushInternalLogs();\r\n            };\r\n            // Add addTelemetryInitializer\r\n            proxyFunctions(_self, function () { return _telemetryInitializerPlugin; }, [\"addTelemetryInitializer\"]);\r\n            _self[_DYN_UNLOAD /* @min:%2eunload */] = function (isAsync, unloadComplete, cbTimeout) {\r\n                var _a;\r\n                if (isAsync === void 0) { isAsync = true; }\r\n                if (!_isInitialized) {\r\n                    // The SDK is not initialized\r\n                    throwError(strSdkNotInitialized);\r\n                }\r\n                // Check if the SDK still unloading so throw\r\n                if (_isUnloading) {\r\n                    // The SDK is already unloading\r\n                    throwError(strSdkUnloadingError);\r\n                }\r\n                var unloadState = (_a = {\r\n                        reason: 50 /* TelemetryUnloadReason.SdkUnload */\r\n                    },\r\n                    _a[_DYN_IS_ASYNC /* @min:isAsync */] = isAsync,\r\n                    _a.flushComplete = false,\r\n                    _a);\r\n                var result;\r\n                if (isAsync && !unloadComplete) {\r\n                    result = createPromise(function (resolve) {\r\n                        // Set the callback to the promise resolve callback\r\n                        unloadComplete = resolve;\r\n                    });\r\n                }\r\n                var processUnloadCtx = createProcessTelemetryUnloadContext(_getPluginChain(), _self);\r\n                processUnloadCtx[_DYN_ON_COMPLETE /* @min:%2eonComplete */](function () {\r\n                    _hookContainer.run(_self[_DYN_LOGGER /* @min:%2elogger */]);\r\n                    // Run any \"unload\" functions for the _cookieManager, _notificationManager and _logger\r\n                    doUnloadAll([_cookieManager, _notificationManager, _logger], isAsync, function () {\r\n                        _initDefaults();\r\n                        unloadComplete && unloadComplete(unloadState);\r\n                    });\r\n                }, _self);\r\n                function _doUnload(flushComplete) {\r\n                    unloadState.flushComplete = flushComplete;\r\n                    _isUnloading = true;\r\n                    // Run all of the unload handlers first (before unloading the plugins)\r\n                    _unloadHandlers.run(processUnloadCtx, unloadState);\r\n                    // Stop polling the internal logs\r\n                    _self[_DYN_STOP_POLLING_INTERNA3 /* @min:%2estopPollingInternalLogs */]();\r\n                    // Start unloading the components, from this point onwards the SDK should be considered to be in an unstable state\r\n                    processUnloadCtx[_DYN_PROCESS_NEXT /* @min:%2eprocessNext */](unloadState);\r\n                }\r\n                _flushInternalLogs();\r\n                if (!_flushChannels(isAsync, _doUnload, 6 /* SendRequestReason.SdkUnload */, cbTimeout)) {\r\n                    _doUnload(false);\r\n                }\r\n                return result;\r\n            };\r\n            _self[_DYN_GET_PLUGIN /* @min:%2egetPlugin */] = _getPlugin;\r\n            _self.addPlugin = function (plugin, replaceExisting, isAsync, addCb) {\r\n                if (!plugin) {\r\n                    addCb && addCb(false);\r\n                    _logOrThrowError(strValidationError);\r\n                    return;\r\n                }\r\n                var existingPlugin = _getPlugin(plugin[_DYN_IDENTIFIER /* @min:%2eidentifier */]);\r\n                if (existingPlugin && !replaceExisting) {\r\n                    addCb && addCb(false);\r\n                    _logOrThrowError(\"Plugin [\" + plugin[_DYN_IDENTIFIER /* @min:%2eidentifier */] + \"] is already loaded!\");\r\n                    return;\r\n                }\r\n                var updateState = {\r\n                    reason: 16 /* TelemetryUpdateReason.PluginAdded */\r\n                };\r\n                function _addPlugin(removed) {\r\n                    _configExtensions[_DYN_PUSH /* @min:%2epush */](plugin);\r\n                    updateState.added = [plugin];\r\n                    // Re-Initialize the plugin chain\r\n                    _initPluginChain(updateState);\r\n                    addCb && addCb(true);\r\n                }\r\n                if (existingPlugin) {\r\n                    var removedPlugins_1 = [existingPlugin.plugin];\r\n                    var unloadState = {\r\n                        reason: 2 /* TelemetryUnloadReason.PluginReplace */,\r\n                        isAsync: !!isAsync\r\n                    };\r\n                    _removePlugins(removedPlugins_1, unloadState, function (removed) {\r\n                        if (!removed) {\r\n                            // Previous plugin was successfully removed or was not installed\r\n                            addCb && addCb(false);\r\n                        }\r\n                        else {\r\n                            updateState.removed = removedPlugins_1;\r\n                            updateState.reason |= 32 /* TelemetryUpdateReason.PluginRemoved */;\r\n                            _addPlugin(true);\r\n                        }\r\n                    });\r\n                }\r\n                else {\r\n                    _addPlugin(false);\r\n                }\r\n            };\r\n            _self.updateCfg = function (newConfig, mergeExisting) {\r\n                if (mergeExisting === void 0) { mergeExisting = true; }\r\n                var updateState;\r\n                if (_self[_DYN_IS_INITIALIZED /* @min:%2eisInitialized */]()) {\r\n                    updateState = {\r\n                        reason: 1 /* TelemetryUpdateReason.ConfigurationChanged */,\r\n                        cfg: _configHandler.cfg,\r\n                        oldCfg: deepExtend({}, _configHandler.cfg),\r\n                        newConfig: deepExtend({}, newConfig),\r\n                        merge: mergeExisting\r\n                    };\r\n                    newConfig = updateState.newConfig;\r\n                    var cfg = _configHandler.cfg;\r\n                    // replace the immutable (if initialized) values\r\n                    // We don't currently allow updating the extensions and channels via the update config\r\n                    // So overwriting any user provided values to reuse the existing values\r\n                    newConfig[STR_EXTENSIONS /* @min:%2eextensions */] = cfg[STR_EXTENSIONS /* @min:%2eextensions */];\r\n                    newConfig[STR_CHANNELS /* @min:%2echannels */] = cfg[STR_CHANNELS /* @min:%2echannels */];\r\n                }\r\n                // Explicitly blocking any previous config watchers so that they don't get called because\r\n                // of this bulk update (Probably not necessary)\r\n                _configHandler._block(function (details) {\r\n                    // Lets assign the new values to the existing config either overwriting or re-assigning\r\n                    var theConfig = details.cfg;\r\n                    _deepMergeConfig(details, theConfig, newConfig, mergeExisting);\r\n                    if (!mergeExisting) {\r\n                        // Remove (unassign) the values \"missing\" from the newConfig and also not in the default config\r\n                        objForEachKey(theConfig, function (key) {\r\n                            if (!objHasOwn(newConfig, key)) {\r\n                                // Set the value to undefined\r\n                                details.set(theConfig, key, UNDEFINED_VALUE);\r\n                            }\r\n                        });\r\n                    }\r\n                    // Apply defaults to the new config\r\n                    details[_DYN_SET_DF /* @min:%2esetDf */](theConfig, defaultConfig);\r\n                }, true);\r\n                // Now execute all of the listeners (synchronously) so they update their values immediately\r\n                _configHandler[_DYN_NOTIFY /* @min:%2enotify */]();\r\n                if (updateState) {\r\n                    _doUpdate(updateState);\r\n                }\r\n            };\r\n            _self.evtNamespace = function () {\r\n                return _evtNamespace;\r\n            };\r\n            _self.flush = _flushChannels;\r\n            _self.getTraceCtx = function (createNew) {\r\n                if (!_traceCtx) {\r\n                    _traceCtx = createDistributedTraceContext();\r\n                }\r\n                return _traceCtx;\r\n            };\r\n            _self.setTraceCtx = function (traceCtx) {\r\n                _traceCtx = traceCtx || null;\r\n            };\r\n            _self.addUnloadHook = _addUnloadHook;\r\n            // Create the addUnloadCb\r\n            proxyFunctionAs(_self, \"addUnloadCb\", function () { return _unloadHandlers; }, \"add\");\r\n            _self.onCfgChange = function (handler) {\r\n                var unloadHook;\r\n                if (!_isInitialized) {\r\n                    unloadHook = _addDelayedCfgListener(_cfgListeners, handler);\r\n                }\r\n                else {\r\n                    unloadHook = onConfigChange(_configHandler.cfg, handler, _self[_DYN_LOGGER /* @min:%2elogger */]);\r\n                }\r\n                return {\r\n                    rm: function () {\r\n                        unloadHook.rm();\r\n                    }\r\n                };\r\n            };\r\n            _self.getWParam = function () {\r\n                return (hasDocument() || !!_configHandler.cfg.enableWParam) ? 0 : -1;\r\n            };\r\n            function _setPluginVersions() {\r\n                var thePlugins = {};\r\n                _pluginVersionStringArr = [];\r\n                var _addPluginVersions = function (plugins) {\r\n                    if (plugins) {\r\n                        arrForEach(plugins, function (plugin) {\r\n                            if (plugin[_DYN_IDENTIFIER /* @min:%2eidentifier */] && plugin[_DYN_VERSION /* @min:%2eversion */] && !thePlugins[plugin.identifier]) {\r\n                                var ver = plugin[_DYN_IDENTIFIER /* @min:%2eidentifier */] + \"=\" + plugin[_DYN_VERSION /* @min:%2eversion */];\r\n                                _pluginVersionStringArr[_DYN_PUSH /* @min:%2epush */](ver);\r\n                                thePlugins[plugin.identifier] = plugin;\r\n                            }\r\n                        });\r\n                    }\r\n                };\r\n                _addPluginVersions(_channels);\r\n                if (_channelConfig) {\r\n                    arrForEach(_channelConfig, function (channels) {\r\n                        _addPluginVersions(channels);\r\n                    });\r\n                }\r\n                _addPluginVersions(_configExtensions);\r\n            }\r\n            function _initDefaults() {\r\n                _isInitialized = false;\r\n                // Use a default logger so initialization errors are not dropped on the floor with full logging\r\n                _configHandler = createDynamicConfig({}, defaultConfig, _self[_DYN_LOGGER /* @min:%2elogger */]);\r\n                // Set the logging level to critical so that any critical initialization failures are displayed on the console\r\n                _configHandler.cfg[_DYN_LOGGING_LEVEL_CONSOL4 /* @min:%2eloggingLevelConsole */] = 1 /* eLoggingSeverity.CRITICAL */;\r\n                // Define _self.config\r\n                objDefine(_self, \"config\", {\r\n                    g: function () { return _configHandler.cfg; },\r\n                    s: function (newValue) {\r\n                        _self.updateCfg(newValue, false);\r\n                    }\r\n                });\r\n                objDefine(_self, \"pluginVersionStringArr\", {\r\n                    g: function () {\r\n                        if (!_pluginVersionStringArr) {\r\n                            _setPluginVersions();\r\n                        }\r\n                        return _pluginVersionStringArr;\r\n                    }\r\n                });\r\n                objDefine(_self, \"pluginVersionString\", {\r\n                    g: function () {\r\n                        if (!_pluginVersionString) {\r\n                            if (!_pluginVersionStringArr) {\r\n                                _setPluginVersions();\r\n                            }\r\n                            _pluginVersionString = _pluginVersionStringArr.join(\";\");\r\n                        }\r\n                        return _pluginVersionString || STR_EMPTY;\r\n                    }\r\n                });\r\n                objDefine(_self, \"logger\", {\r\n                    g: function () {\r\n                        if (!_logger) {\r\n                            _logger = new DiagnosticLogger(_configHandler.cfg);\r\n                            _configHandler[_DYN_LOGGER /* @min:%2elogger */] = _logger;\r\n                        }\r\n                        return _logger;\r\n                    },\r\n                    s: function (newLogger) {\r\n                        _configHandler[_DYN_LOGGER /* @min:%2elogger */] = newLogger;\r\n                        if (_logger !== newLogger) {\r\n                            runTargetUnload(_logger, false);\r\n                            _logger = newLogger;\r\n                        }\r\n                    }\r\n                });\r\n                _self[_DYN_LOGGER /* @min:%2elogger */] = new DiagnosticLogger(_configHandler.cfg);\r\n                _extensions = [];\r\n                var cfgExtensions = _self.config[STR_EXTENSIONS /* @min:%2eextensions */] || [];\r\n                cfgExtensions.splice(0, cfgExtensions[_DYN_LENGTH /* @min:%2elength */]);\r\n                arrAppend(cfgExtensions, _extensions);\r\n                _telemetryInitializerPlugin = new TelemetryInitializerPlugin();\r\n                _eventQueue = [];\r\n                runTargetUnload(_notificationManager, false);\r\n                _notificationManager = null;\r\n                _perfManager = null;\r\n                _cfgPerfManager = null;\r\n                runTargetUnload(_cookieManager, false);\r\n                _cookieManager = null;\r\n                _pluginChain = null;\r\n                _configExtensions = [];\r\n                _channelConfig = null;\r\n                _channels = null;\r\n                _isUnloading = false;\r\n                _internalLogsEventName = null;\r\n                _evtNamespace = createUniqueNamespace(\"AIBaseCore\", true);\r\n                _unloadHandlers = createUnloadHandlerContainer();\r\n                _traceCtx = null;\r\n                _instrumentationKey = null;\r\n                _hookContainer = createUnloadHookContainer();\r\n                _cfgListeners = [];\r\n                _pluginVersionString = null;\r\n                _pluginVersionStringArr = null;\r\n                _forceStopInternalLogPoller = false;\r\n            }\r\n            function _createTelCtx() {\r\n                var theCtx = createProcessTelemetryContext(_getPluginChain(), _configHandler.cfg, _self);\r\n                theCtx[_DYN_ON_COMPLETE /* @min:%2eonComplete */](_startLogPoller);\r\n                return theCtx;\r\n            }\r\n            // Initialize or Re-initialize the plugins\r\n            function _initPluginChain(updateState) {\r\n                // Extension validation\r\n                var theExtensions = _validateExtensions(_self[_DYN_LOGGER /* @min:%2elogger */], ChannelControllerPriority, _configExtensions);\r\n                _pluginChain = null;\r\n                _pluginVersionString = null;\r\n                _pluginVersionStringArr = null;\r\n                // Get the primary channel queue and include as part of the normal extensions\r\n                _channels = (_channelConfig || [])[0] || [];\r\n                // Add any channels provided in the extensions and sort them\r\n                _channels = sortPlugins(arrAppend(_channels, theExtensions[STR_CHANNELS /* @min:%2echannels */]));\r\n                // Create an array of all extensions, including the _channels\r\n                var allExtensions = arrAppend(sortPlugins(theExtensions[STR_CORE /* @min:%2ecore */]), _channels);\r\n                // Required to allow plugins to call core.getPlugin() during their own initialization\r\n                _extensions = objFreeze(allExtensions);\r\n                // This has a side effect of adding the extensions passed during initialization\r\n                // into the config.extensions, so you can see all of the extensions loaded.\r\n                // This will also get updated by the addPlugin() and remove plugin code.\r\n                var cfgExtensions = _self.config[STR_EXTENSIONS /* @min:%2eextensions */] || [];\r\n                cfgExtensions.splice(0, cfgExtensions[_DYN_LENGTH /* @min:%2elength */]);\r\n                arrAppend(cfgExtensions, _extensions);\r\n                var rootCtx = _createTelCtx();\r\n                // Initializing the channels first\r\n                if (_channels && _channels[_DYN_LENGTH /* @min:%2elength */] > 0) {\r\n                    initializePlugins(rootCtx[_DYN_CREATE_NEW /* @min:%2ecreateNew */](_channels), allExtensions);\r\n                }\r\n                // Now initialize the normal extensions (explicitly not including the _channels as this can cause duplicate initialization)\r\n                initializePlugins(rootCtx, allExtensions);\r\n                if (updateState) {\r\n                    _doUpdate(updateState);\r\n                }\r\n            }\r\n            function _getPlugin(pluginIdentifier) {\r\n                var theExt = null;\r\n                var thePlugin = null;\r\n                var channelHosts = [];\r\n                arrForEach(_extensions, function (ext) {\r\n                    if (ext[_DYN_IDENTIFIER /* @min:%2eidentifier */] === pluginIdentifier && ext !== _telemetryInitializerPlugin) {\r\n                        thePlugin = ext;\r\n                        return -1;\r\n                    }\r\n                    if (ext.getChannel) {\r\n                        channelHosts[_DYN_PUSH /* @min:%2epush */](ext);\r\n                    }\r\n                });\r\n                if (!thePlugin && channelHosts[_DYN_LENGTH /* @min:%2elength */] > 0) {\r\n                    arrForEach(channelHosts, function (host) {\r\n                        thePlugin = host.getChannel(pluginIdentifier);\r\n                        if (!thePlugin) {\r\n                            return -1;\r\n                        }\r\n                    });\r\n                }\r\n                if (thePlugin) {\r\n                    theExt = {\r\n                        plugin: thePlugin,\r\n                        setEnabled: function (enabled) {\r\n                            _getPluginState(thePlugin)[STR_DISABLED] = !enabled;\r\n                        },\r\n                        isEnabled: function () {\r\n                            var pluginState = _getPluginState(thePlugin);\r\n                            return !pluginState[_DYN_TEARDOWN /* @min:%2eteardown */] && !pluginState[STR_DISABLED];\r\n                        },\r\n                        remove: function (isAsync, removeCb) {\r\n                            var _a;\r\n                            if (isAsync === void 0) { isAsync = true; }\r\n                            var pluginsToRemove = [thePlugin];\r\n                            var unloadState = (_a = {\r\n                                    reason: 1 /* TelemetryUnloadReason.PluginUnload */\r\n                                },\r\n                                _a[_DYN_IS_ASYNC /* @min:isAsync */] = isAsync,\r\n                                _a);\r\n                            _removePlugins(pluginsToRemove, unloadState, function (removed) {\r\n                                if (removed) {\r\n                                    // Re-Initialize the plugin chain\r\n                                    _initPluginChain({\r\n                                        reason: 32 /* TelemetryUpdateReason.PluginRemoved */,\r\n                                        removed: pluginsToRemove\r\n                                    });\r\n                                }\r\n                                removeCb && removeCb(removed);\r\n                            });\r\n                        }\r\n                    };\r\n                }\r\n                return theExt;\r\n            }\r\n            function _getPluginChain() {\r\n                if (!_pluginChain) {\r\n                    // copy the collection of extensions\r\n                    var extensions = (_extensions || []).slice();\r\n                    // During add / remove this may get called again, so don't read if already present\r\n                    if (arrIndexOf(extensions, _telemetryInitializerPlugin) === -1) {\r\n                        extensions[_DYN_PUSH /* @min:%2epush */](_telemetryInitializerPlugin);\r\n                    }\r\n                    _pluginChain = createTelemetryProxyChain(sortPlugins(extensions), _configHandler.cfg, _self);\r\n                }\r\n                return _pluginChain;\r\n            }\r\n            function _removePlugins(thePlugins, unloadState, removeComplete) {\r\n                if (thePlugins && thePlugins[_DYN_LENGTH /* @min:%2elength */] > 0) {\r\n                    var unloadChain = createTelemetryProxyChain(thePlugins, _configHandler.cfg, _self);\r\n                    var unloadCtx = createProcessTelemetryUnloadContext(unloadChain, _self);\r\n                    unloadCtx[_DYN_ON_COMPLETE /* @min:%2eonComplete */](function () {\r\n                        var removed = false;\r\n                        // Remove the listed config extensions\r\n                        var newConfigExtensions = [];\r\n                        arrForEach(_configExtensions, function (plugin, idx) {\r\n                            if (!_isPluginPresent(plugin, thePlugins)) {\r\n                                newConfigExtensions[_DYN_PUSH /* @min:%2epush */](plugin);\r\n                            }\r\n                            else {\r\n                                removed = true;\r\n                            }\r\n                        });\r\n                        _configExtensions = newConfigExtensions;\r\n                        _pluginVersionString = null;\r\n                        _pluginVersionStringArr = null;\r\n                        // Re-Create the channel config\r\n                        var newChannelConfig = [];\r\n                        if (_channelConfig) {\r\n                            arrForEach(_channelConfig, function (queue, idx) {\r\n                                var newQueue = [];\r\n                                arrForEach(queue, function (channel) {\r\n                                    if (!_isPluginPresent(channel, thePlugins)) {\r\n                                        newQueue[_DYN_PUSH /* @min:%2epush */](channel);\r\n                                    }\r\n                                    else {\r\n                                        removed = true;\r\n                                    }\r\n                                });\r\n                                newChannelConfig[_DYN_PUSH /* @min:%2epush */](newQueue);\r\n                            });\r\n                            _channelConfig = newChannelConfig;\r\n                        }\r\n                        removeComplete && removeComplete(removed);\r\n                        _startLogPoller();\r\n                    });\r\n                    unloadCtx[_DYN_PROCESS_NEXT /* @min:%2eprocessNext */](unloadState);\r\n                }\r\n                else {\r\n                    removeComplete(false);\r\n                }\r\n            }\r\n            function _flushInternalLogs() {\r\n                if (_logger && _logger.queue) {\r\n                    var queue = _logger.queue.slice(0);\r\n                    _logger.queue[_DYN_LENGTH /* @min:%2elength */] = 0;\r\n                    arrForEach(queue, function (logMessage) {\r\n                        var _a;\r\n                        var item = (_a = {},\r\n                            _a[_DYN_NAME /* @min:name */] = _internalLogsEventName ? _internalLogsEventName : \"InternalMessageId: \" + logMessage[_DYN_MESSAGE_ID /* @min:%2emessageId */],\r\n                            _a.iKey = _instrumentationKey,\r\n                            _a[_DYN_TIME /* @min:time */] = toISOString(new Date()),\r\n                            _a.baseType = _InternalLogMessage.dataType,\r\n                            _a.baseData = { message: logMessage[_DYN_MESSAGE /* @min:%2emessage */] },\r\n                            _a);\r\n                        _self.track(item);\r\n                    });\r\n                }\r\n            }\r\n            function _flushChannels(isAsync, callBack, sendReason, cbTimeout) {\r\n                // Setting waiting to one so that we don't call the callBack until we finish iterating\r\n                var waiting = 1;\r\n                var doneIterating = false;\r\n                var cbTimer = null;\r\n                cbTimeout = cbTimeout || 5000;\r\n                function doCallback() {\r\n                    waiting--;\r\n                    if (doneIterating && waiting === 0) {\r\n                        cbTimer && cbTimer[_DYN_CANCEL /* @min:%2ecancel */]();\r\n                        cbTimer = null;\r\n                        callBack && callBack(doneIterating);\r\n                        callBack = null;\r\n                    }\r\n                }\r\n                if (_channels && _channels[_DYN_LENGTH /* @min:%2elength */] > 0) {\r\n                    var flushCtx = _createTelCtx()[_DYN_CREATE_NEW /* @min:%2ecreateNew */](_channels);\r\n                    flushCtx.iterate(function (plugin) {\r\n                        if (plugin.flush) {\r\n                            waiting++;\r\n                            var handled_1 = false;\r\n                            // Not all channels will call this callback for every scenario\r\n                            if (!plugin.flush(isAsync, function () {\r\n                                handled_1 = true;\r\n                                doCallback();\r\n                            }, sendReason)) {\r\n                                if (!handled_1) {\r\n                                    // If any channel doesn't return true and it didn't call the callback, then we should assume that the callback\r\n                                    // will never be called, so use a timeout to allow the channel(s) some time to \"finish\" before triggering any\r\n                                    // followup function (such as unloading)\r\n                                    if (isAsync && cbTimer == null) {\r\n                                        cbTimer = scheduleTimeout(function () {\r\n                                            cbTimer = null;\r\n                                            doCallback();\r\n                                        }, cbTimeout);\r\n                                    }\r\n                                    else {\r\n                                        doCallback();\r\n                                    }\r\n                                }\r\n                            }\r\n                        }\r\n                    });\r\n                }\r\n                doneIterating = true;\r\n                doCallback();\r\n                return true;\r\n            }\r\n            function _initDebugListener() {\r\n                // Lazily ensure that the notification manager is created\r\n                !_notificationManager && _self[_DYN_GET_NOTIFY_MGR /* @min:%2egetNotifyMgr */]();\r\n                // Will get recalled if any referenced config values are changed\r\n                _addUnloadHook(_configHandler[_DYN_WATCH /* @min:%2ewatch */](function (details) {\r\n                    var disableDbgExt = details.cfg.disableDbgExt;\r\n                    if (disableDbgExt === true && _debugListener) {\r\n                        // Remove any previously loaded debug listener\r\n                        _notificationManager[_DYN_REMOVE_NOTIFICATION_2 /* @min:%2eremoveNotificationListener */](_debugListener);\r\n                        _debugListener = null;\r\n                    }\r\n                    if (_notificationManager && !_debugListener && disableDbgExt !== true) {\r\n                        _debugListener = getDebugListener(details.cfg);\r\n                        _notificationManager[_DYN_ADD_NOTIFICATION_LIS1 /* @min:%2eaddNotificationListener */](_debugListener);\r\n                    }\r\n                }));\r\n            }\r\n            function _initPerfManager() {\r\n                // Will get recalled if any referenced config values are changed\r\n                _addUnloadHook(_configHandler[_DYN_WATCH /* @min:%2ewatch */](function (details) {\r\n                    var enablePerfMgr = details.cfg.enablePerfMgr;\r\n                    if (!enablePerfMgr && _cfgPerfManager) {\r\n                        // Remove any existing config based performance manager\r\n                        _cfgPerfManager = null;\r\n                    }\r\n                    if (enablePerfMgr) {\r\n                        // Set the performance manager creation function if not defined\r\n                        getSetValue(details.cfg, STR_CREATE_PERF_MGR, _createPerfManager);\r\n                    }\r\n                }));\r\n            }\r\n            function _doUpdate(updateState) {\r\n                var updateCtx = createProcessTelemetryUpdateContext(_getPluginChain(), _self);\r\n                updateCtx[_DYN_ON_COMPLETE /* @min:%2eonComplete */](_startLogPoller);\r\n                if (!_self._updateHook || _self._updateHook(updateCtx, updateState) !== true) {\r\n                    updateCtx[_DYN_PROCESS_NEXT /* @min:%2eprocessNext */](updateState);\r\n                }\r\n            }\r\n            function _logOrThrowError(message) {\r\n                var logger = _self[_DYN_LOGGER /* @min:%2elogger */];\r\n                if (logger) {\r\n                    // there should always be a logger\r\n                    _throwInternal(logger, 2 /* eLoggingSeverity.WARNING */, 73 /* _eInternalMessageId.PluginException */, message);\r\n                    _startLogPoller();\r\n                }\r\n                else {\r\n                    throwError(message);\r\n                }\r\n            }\r\n            function _notifyInvalidEvent(telemetryItem) {\r\n                var manager = _self[_DYN_GET_NOTIFY_MGR /* @min:%2egetNotifyMgr */]();\r\n                if (manager) {\r\n                    manager[STR_EVENTS_DISCARDED /* @min:%2eeventsDiscarded */]([telemetryItem], 2 /* eEventsDiscardedReason.InvalidEvent */);\r\n                }\r\n            }\r\n            function _addUnloadHook(hooks) {\r\n                _hookContainer.add(hooks);\r\n            }\r\n        });\r\n    }\r\n    AppInsightsCore.prototype.initialize = function (config, extensions, logger, notificationManager) {\r\n        // @DynamicProtoStub -- DO NOT add any code as this will be removed during packaging\r\n    };\r\n    AppInsightsCore.prototype.getChannels = function () {\r\n        // @DynamicProtoStub -- DO NOT add any code as this will be removed during packaging\r\n        return null;\r\n    };\r\n    AppInsightsCore.prototype.track = function (telemetryItem) {\r\n        // @DynamicProtoStub -- DO NOT add any code as this will be removed during packaging\r\n    };\r\n    AppInsightsCore.prototype.getProcessTelContext = function () {\r\n        // @DynamicProtoStub -- DO NOT add any code as this will be removed during packaging\r\n        return null;\r\n    };\r\n    AppInsightsCore.prototype.getNotifyMgr = function () {\r\n        // @DynamicProtoStub -- DO NOT add any code as this will be removed during packaging\r\n        return null;\r\n    };\r\n    /**\r\n     * Adds a notification listener. The SDK calls methods on the listener when an appropriate notification is raised.\r\n     * The added plugins must raise notifications. If the plugins do not implement the notifications, then no methods will be\r\n     * called.\r\n     * @param listener - An INotificationListener object.\r\n     */\r\n    AppInsightsCore.prototype.addNotificationListener = function (listener) {\r\n        // @DynamicProtoStub -- DO NOT add any code as this will be removed during packaging\r\n    };\r\n    /**\r\n     * Removes all instances of the listener.\r\n     * @param listener - INotificationListener to remove.\r\n     */\r\n    AppInsightsCore.prototype.removeNotificationListener = function (listener) {\r\n        // @DynamicProtoStub -- DO NOT add any code as this will be removed during packaging\r\n    };\r\n    /**\r\n     * Get the current cookie manager for this instance\r\n     */\r\n    AppInsightsCore.prototype.getCookieMgr = function () {\r\n        // @DynamicProtoStub -- DO NOT add any code as this will be removed during packaging\r\n        return null;\r\n    };\r\n    /**\r\n     * Set the current cookie manager for this instance\r\n     * @param cookieMgr - The manager, if set to null/undefined will cause the default to be created\r\n     */\r\n    AppInsightsCore.prototype.setCookieMgr = function (cookieMgr) {\r\n        // @DynamicProtoStub -- DO NOT add any code as this will be removed during packaging\r\n    };\r\n    AppInsightsCore.prototype.getPerfMgr = function () {\r\n        // @DynamicProtoStub -- DO NOT add any code as this will be removed during packaging\r\n        return null;\r\n    };\r\n    AppInsightsCore.prototype.setPerfMgr = function (perfMgr) {\r\n        // @DynamicProtoStub -- DO NOT add any code as this will be removed during packaging\r\n    };\r\n    AppInsightsCore.prototype.eventCnt = function () {\r\n        // @DynamicProtoStub -- DO NOT add any code as this will be removed during packaging\r\n        return 0;\r\n    };\r\n    /**\r\n     * Enable the timer that checks the logger.queue for log messages to be flushed.\r\n     * Note: Since 3.0.1 and 2.8.13 this is no longer an interval timer but is a normal\r\n     * timer that is only started when this function is called and then subsequently\r\n     * only _if_ there are any logger.queue messages to be sent.\r\n     */\r\n    AppInsightsCore.prototype.pollInternalLogs = function (eventName) {\r\n        // @DynamicProtoStub -- DO NOT add any code as this will be removed during packaging\r\n        return null;\r\n    };\r\n    /**\r\n     * Stop the timer that log messages from logger.queue when available\r\n     */\r\n    AppInsightsCore.prototype.stopPollingInternalLogs = function () {\r\n        // @DynamicProtoStub -- DO NOT add any code as this will be removed during packaging\r\n    };\r\n    /**\r\n     * Add a telemetry processor to decorate or drop telemetry events.\r\n     * @param telemetryInitializer - The Telemetry Initializer function\r\n     * @returns - A ITelemetryInitializerHandler to enable the initializer to be removed\r\n     */\r\n    AppInsightsCore.prototype.addTelemetryInitializer = function (telemetryInitializer) {\r\n        // @DynamicProtoStub -- DO NOT add any code as this will be removed during packaging\r\n        return null;\r\n    };\r\n    /**\r\n     * Unload and Tear down the SDK and any initialized plugins, after calling this the SDK will be considered\r\n     * to be un-initialized and non-operational, re-initializing the SDK should only be attempted if the previous\r\n     * unload call return `true` stating that all plugins reported that they also unloaded, the recommended\r\n     * approach is to create a new instance and initialize that instance.\r\n     * This is due to possible unexpected side effects caused by plugins not supporting unload / teardown, unable\r\n     * to successfully remove any global references or they may just be completing the unload process asynchronously.\r\n     * If you pass isAsync as `true` (also the default) and DO NOT pass a callback function then an [IPromise](https://nevware21.github.io/ts-async/typedoc/interfaces/IPromise.html)\r\n     * will be returned which will resolve once the unload is complete. The actual implementation of the `IPromise`\r\n     * will be a native Promise (if supported) or the default as supplied by [ts-async library](https://github.com/nevware21/ts-async)\r\n     * @param isAsync - Can the unload be performed asynchronously (default)\r\n     * @param unloadComplete - An optional callback that will be called once the unload has completed\r\n     * @param cbTimeout - An optional timeout to wait for any flush operations to complete before proceeding with the\r\n     * unload. Defaults to 5 seconds.\r\n     * @return Nothing or if occurring asynchronously a [IPromise](https://nevware21.github.io/ts-async/typedoc/interfaces/IPromise.html)\r\n     * which will be resolved once the unload is complete, the [IPromise](https://nevware21.github.io/ts-async/typedoc/interfaces/IPromise.html)\r\n     * will only be returned when no callback is provided and isAsync is true\r\n     */\r\n    AppInsightsCore.prototype.unload = function (isAsync, unloadComplete, cbTimeout) {\r\n        // @DynamicProtoStub -- DO NOT add any code as this will be removed during packaging\r\n    };\r\n    AppInsightsCore.prototype.getPlugin = function (pluginIdentifier) {\r\n        // @DynamicProtoStub -- DO NOT add any code as this will be removed during packaging\r\n        return null;\r\n    };\r\n    /**\r\n     * Add a new plugin to the installation\r\n     * @param plugin - The new plugin to add\r\n     * @param replaceExisting - should any existing plugin be replaced, default is false\r\n     * @param doAsync - Should the add be performed asynchronously\r\n     * @param addCb - [Optional] callback to call after the plugin has been added\r\n     */\r\n    AppInsightsCore.prototype.addPlugin = function (plugin, replaceExisting, doAsync, addCb) {\r\n        // @DynamicProtoStub -- DO NOT add any code as this will be removed during packaging\r\n    };\r\n    /**\r\n     * Update the configuration used and broadcast the changes to all loaded plugins\r\n     * @param newConfig - The new configuration is apply\r\n     * @param mergeExisting - Should the new configuration merge with the existing or just replace it. Default is to true.\r\n     */\r\n    AppInsightsCore.prototype.updateCfg = function (newConfig, mergeExisting) {\r\n        // @DynamicProtoStub -- DO NOT add any code as this will be removed during packaging\r\n    };\r\n    /**\r\n     * Returns the unique event namespace that should be used\r\n     */\r\n    AppInsightsCore.prototype.evtNamespace = function () {\r\n        // @DynamicProtoStub -- DO NOT add any code as this will be removed during packaging\r\n        return null;\r\n    };\r\n    /**\r\n     * Add an unload handler that will be called when the SDK is being unloaded\r\n     * @param handler - the handler\r\n     */\r\n    AppInsightsCore.prototype.addUnloadCb = function (handler) {\r\n        // @DynamicProtoStub -- DO NOT add any code as this will be removed during packaging\r\n    };\r\n    /**\r\n     * Flush and send any batched / cached data immediately\r\n     * @param async - send data asynchronously when true (defaults to true)\r\n     * @param callBack - if specified, notify caller when send is complete, the channel should return true to indicate to the caller that it will be called.\r\n     * If the caller doesn't return true the caller should assume that it may never be called.\r\n     * @param sendReason - specify the reason that you are calling \"flush\" defaults to ManualFlush (1) if not specified\r\n     * @returns - true if the callback will be return after the flush is complete otherwise the caller should assume that any provided callback will never be called\r\n     */\r\n    AppInsightsCore.prototype.flush = function (isAsync, callBack, sendReason) {\r\n        // @DynamicProtoStub -- DO NOT add any code as this will be removed during packaging\r\n    };\r\n    /**\r\n     * Gets the current distributed trace context for this instance if available\r\n     * @param createNew - Optional flag to create a new instance if one doesn't currently exist, defaults to true\r\n     */\r\n    AppInsightsCore.prototype.getTraceCtx = function (createNew) {\r\n        // @DynamicProtoStub -- DO NOT add any code as this will be removed during packaging\r\n        return null;\r\n    };\r\n    /**\r\n     * Sets the current distributed trace context for this instance if available\r\n     */\r\n    AppInsightsCore.prototype.setTraceCtx = function (newTracectx) {\r\n        // @DynamicProtoStub -- DO NOT add any code as this will be removed during packaging\r\n    };\r\n    /**\r\n     * Add this hook so that it is automatically removed during unloading\r\n     * @param hooks - The single hook or an array of IInstrumentHook objects\r\n     */\r\n    AppInsightsCore.prototype.addUnloadHook = function (hooks) {\r\n        // @DynamicProtoStub -- DO NOT add any code as this will be removed during packaging\r\n    };\r\n    /**\r\n     * Watches and tracks changes for accesses to the current config, and if the accessed config changes the\r\n     * handler will be recalled.\r\n     * @param handler\r\n     * @returns A watcher handler instance that can be used to remove itself when being unloaded\r\n     */\r\n    AppInsightsCore.prototype.onCfgChange = function (handler) {\r\n        // @DynamicProtoStub -- DO NOT add any code as this will be removed during packaging\r\n        return null;\r\n    };\r\n    AppInsightsCore.prototype.releaseQueue = function () {\r\n        // @DynamicProtoStub -- DO NOT add any code as this will be removed during packaging\r\n    };\r\n    /**\r\n     * Hook for Core extensions to allow them to update their own configuration before updating all of the plugins.\r\n     * @param updateCtx - The plugin update context\r\n     * @param updateState - The Update State\r\n     * @returns boolean - True means the extension class will call updateState otherwise the Core will\r\n     */\r\n    AppInsightsCore.prototype._updateHook = function (updateCtx, updateState) {\r\n        // @DynamicProtoStub -- DO NOT add any code as this will be removed during packaging\r\n        return false;\r\n    };\r\n    return AppInsightsCore;\r\n}());\r\nexport { AppInsightsCore };\r\n//# sourceMappingURL=AppInsightsCore.js.map","// Copyright (c) Microsoft Corporation. All rights reserved.\r\n// Licensed under the MIT License.\r\nimport { arrForEach, arrIndexOf, getDocument, getWindow, isArray, objForEachKey, objKeys } from \"@nevware21/ts-utils\";\r\nimport { _DYN_HANDLER, _DYN_LENGTH, _DYN_NAME, _DYN_PUSH, _DYN_REPLACE, _DYN_SPLICE, _DYN_SPLIT, _DYN_TYPE } from \"../__DynamicConstants\";\r\nimport { createElmNodeData, createUniqueNamespace } from \"./DataCacheHelper\";\r\nimport { STR_EMPTY } from \"./InternalConstants\";\r\n// Added to help with minfication\r\nvar strOnPrefix = \"on\";\r\nvar strAttachEvent = \"attachEvent\";\r\nvar strAddEventHelper = \"addEventListener\";\r\nvar strDetachEvent = \"detachEvent\";\r\nvar strRemoveEventListener = \"removeEventListener\";\r\nvar strEvents = \"events\";\r\nvar strVisibilityChangeEvt = \"visibilitychange\";\r\nvar strPageHide = \"pagehide\";\r\nvar strPageShow = \"pageshow\";\r\nvar strUnload = \"unload\";\r\nvar strBeforeUnload = \"beforeunload\";\r\nvar strPageHideNamespace = createUniqueNamespace(\"aiEvtPageHide\");\r\nvar strPageShowNamespace = createUniqueNamespace(\"aiEvtPageShow\");\r\nvar rRemoveEmptyNs = /\\.[\\.]+/g;\r\nvar rRemoveTrailingEmptyNs = /[\\.]+$/;\r\nvar _guid = 1;\r\nvar elmNodeData = createElmNodeData(\"events\");\r\nvar eventNamespace = /^([^.]*)(?:\\.(.+)|)/;\r\nfunction _normalizeNamespace(name) {\r\n    if (name && name[_DYN_REPLACE /* @min:%2ereplace */]) {\r\n        return name[_DYN_REPLACE /* @min:%2ereplace */](/^[\\s\\.]+|(?=[\\s\\.])[\\.\\s]+$/g, STR_EMPTY);\r\n    }\r\n    return name;\r\n}\r\nfunction _getEvtNamespace(eventName, evtNamespace) {\r\n    var _a;\r\n    if (evtNamespace) {\r\n        var theNamespace_1 = STR_EMPTY;\r\n        if (isArray(evtNamespace)) {\r\n            theNamespace_1 = STR_EMPTY;\r\n            arrForEach(evtNamespace, function (name) {\r\n                name = _normalizeNamespace(name);\r\n                if (name) {\r\n                    if (name[0] !== \".\") {\r\n                        name = \".\" + name;\r\n                    }\r\n                    theNamespace_1 += name;\r\n                }\r\n            });\r\n        }\r\n        else {\r\n            theNamespace_1 = _normalizeNamespace(evtNamespace);\r\n        }\r\n        if (theNamespace_1) {\r\n            if (theNamespace_1[0] !== \".\") {\r\n                theNamespace_1 = \".\" + theNamespace_1;\r\n            }\r\n            // We may only have the namespace and not an eventName\r\n            eventName = (eventName || STR_EMPTY) + theNamespace_1;\r\n        }\r\n    }\r\n    var parsedEvent = (eventNamespace.exec(eventName || STR_EMPTY) || []);\r\n    return _a = {},\r\n        _a[_DYN_TYPE /* @min:type */] = parsedEvent[1],\r\n        _a.ns = ((parsedEvent[2] || STR_EMPTY).replace(rRemoveEmptyNs, \".\").replace(rRemoveTrailingEmptyNs, STR_EMPTY)[_DYN_SPLIT /* @min:%2esplit */](\".\").sort()).join(\".\"),\r\n        _a;\r\n}\r\n/**\r\n * Get all of the registered events on the target object, this is primarily used for testing cleanup but may also be used by\r\n * applications to remove their own events\r\n * @param target - The EventTarget that has registered events\r\n * @param eventName - [Optional] The name of the event to return the registered handlers and full name (with namespaces)\r\n * @param evtNamespace - [Optional] Additional namespace(s) to append to the event listeners so they can be uniquely identified and removed based on this namespace,\r\n * if the eventName also includes a namespace the namespace(s) are merged into a single namespace\r\n */\r\nexport function __getRegisteredEvents(target, eventName, evtNamespace) {\r\n    var theEvents = [];\r\n    var eventCache = elmNodeData.get(target, strEvents, {}, false);\r\n    var evtName = _getEvtNamespace(eventName, evtNamespace);\r\n    objForEachKey(eventCache, function (evtType, registeredEvents) {\r\n        arrForEach(registeredEvents, function (value) {\r\n            var _a;\r\n            if (!evtName[_DYN_TYPE /* @min:%2etype */] || evtName[_DYN_TYPE /* @min:%2etype */] === value.evtName[_DYN_TYPE /* @min:%2etype */]) {\r\n                if (!evtName.ns || evtName.ns === evtName.ns) {\r\n                    theEvents[_DYN_PUSH /* @min:%2epush */]((_a = {},\r\n                        _a[_DYN_NAME /* @min:name */] = value.evtName[_DYN_TYPE /* @min:%2etype */] + (value.evtName.ns ? \".\" + value.evtName.ns : STR_EMPTY),\r\n                        _a.handler = value[_DYN_HANDLER /* @min:%2ehandler */],\r\n                        _a));\r\n                }\r\n            }\r\n        });\r\n    });\r\n    return theEvents;\r\n}\r\n// Exported for internal unit testing only\r\nfunction _getRegisteredEvents(target, evtName, addDefault) {\r\n    if (addDefault === void 0) { addDefault = true; }\r\n    var aiEvts = elmNodeData.get(target, strEvents, {}, addDefault);\r\n    var registeredEvents = aiEvts[evtName];\r\n    if (!registeredEvents) {\r\n        registeredEvents = aiEvts[evtName] = [];\r\n    }\r\n    return registeredEvents;\r\n}\r\nfunction _doDetach(obj, evtName, handlerRef, useCapture) {\r\n    if (obj && evtName && evtName[_DYN_TYPE /* @min:%2etype */]) {\r\n        if (obj[strRemoveEventListener]) {\r\n            obj[strRemoveEventListener](evtName[_DYN_TYPE /* @min:%2etype */], handlerRef, useCapture);\r\n        }\r\n        else if (obj[strDetachEvent]) {\r\n            obj[strDetachEvent](strOnPrefix + evtName[_DYN_TYPE /* @min:%2etype */], handlerRef);\r\n        }\r\n    }\r\n}\r\nfunction _doAttach(obj, evtName, handlerRef, useCapture) {\r\n    var result = false;\r\n    if (obj && evtName && evtName[_DYN_TYPE /* @min:%2etype */] && handlerRef) {\r\n        if (obj[strAddEventHelper]) {\r\n            // all browsers except IE before version 9\r\n            obj[strAddEventHelper](evtName[_DYN_TYPE /* @min:%2etype */], handlerRef, useCapture);\r\n            result = true;\r\n        }\r\n        else if (obj[strAttachEvent]) {\r\n            // IE before version 9\r\n            obj[strAttachEvent](strOnPrefix + evtName[_DYN_TYPE /* @min:%2etype */], handlerRef);\r\n            result = true;\r\n        }\r\n    }\r\n    return result;\r\n}\r\nfunction _doUnregister(target, events, evtName, unRegFn) {\r\n    var idx = events[_DYN_LENGTH /* @min:%2elength */];\r\n    while (idx--) {\r\n        var theEvent = events[idx];\r\n        if (theEvent) {\r\n            if (!evtName.ns || evtName.ns === theEvent.evtName.ns) {\r\n                if (!unRegFn || unRegFn(theEvent)) {\r\n                    _doDetach(target, theEvent.evtName, theEvent[_DYN_HANDLER /* @min:%2ehandler */], theEvent.capture);\r\n                    // Remove the registered event\r\n                    events[_DYN_SPLICE /* @min:%2esplice */](idx, 1);\r\n                }\r\n            }\r\n        }\r\n    }\r\n}\r\nfunction _unregisterEvents(target, evtName, unRegFn) {\r\n    if (evtName[_DYN_TYPE /* @min:%2etype */]) {\r\n        _doUnregister(target, _getRegisteredEvents(target, evtName[_DYN_TYPE /* @min:%2etype */]), evtName, unRegFn);\r\n    }\r\n    else {\r\n        var eventCache = elmNodeData.get(target, strEvents, {});\r\n        objForEachKey(eventCache, function (evtType, events) {\r\n            _doUnregister(target, events, evtName, unRegFn);\r\n        });\r\n        // Cleanup\r\n        if (objKeys(eventCache)[_DYN_LENGTH /* @min:%2elength */] === 0) {\r\n            elmNodeData.kill(target, strEvents);\r\n        }\r\n    }\r\n}\r\nexport function mergeEvtNamespace(theNamespace, namespaces) {\r\n    var newNamespaces;\r\n    if (namespaces) {\r\n        if (isArray(namespaces)) {\r\n            newNamespaces = [theNamespace].concat(namespaces);\r\n        }\r\n        else {\r\n            newNamespaces = [theNamespace, namespaces];\r\n        }\r\n        // resort the namespaces so they are always in order\r\n        newNamespaces = (_getEvtNamespace(\"xx\", newNamespaces).ns)[_DYN_SPLIT /* @min:%2esplit */](\".\");\r\n    }\r\n    else {\r\n        newNamespaces = theNamespace;\r\n    }\r\n    return newNamespaces;\r\n}\r\n/**\r\n * Binds the specified function to an event, so that the function gets called whenever the event fires on the object\r\n * @param obj - Object to add the event too.\r\n * @param eventName - String that specifies any of the standard DHTML Events without \"on\" prefix, if may also include an optional (dot \".\" prefixed)\r\n * namespaces \"click\" \"click.mynamespace\" in addition to specific namespaces.\r\n * @param handlerRef - Pointer that specifies the function to call when event fires\r\n * @param evtNamespace - [Optional] Additional namespace(s) to append to the event listeners so they can be uniquely identified and removed based on this namespace,\r\n * if the eventName also includes a namespace the namespace(s) are merged into a single namespace\r\n * @param useCapture - [Optional] Defaults to false\r\n * @returns True if the function was bound successfully to the event, otherwise false\r\n */\r\nexport function eventOn(target, eventName, handlerRef, evtNamespace, useCapture) {\r\n    var _a;\r\n    if (useCapture === void 0) { useCapture = false; }\r\n    var result = false;\r\n    if (target) {\r\n        try {\r\n            var evtName = _getEvtNamespace(eventName, evtNamespace);\r\n            result = _doAttach(target, evtName, handlerRef, useCapture);\r\n            if (result && elmNodeData.accept(target)) {\r\n                var registeredEvent = (_a = {\r\n                        guid: _guid++,\r\n                        evtName: evtName\r\n                    },\r\n                    _a[_DYN_HANDLER /* @min:handler */] = handlerRef,\r\n                    _a.capture = useCapture,\r\n                    _a);\r\n                _getRegisteredEvents(target, evtName.type)[_DYN_PUSH /* @min:%2epush */](registeredEvent);\r\n            }\r\n        }\r\n        catch (e) {\r\n            // Just Ignore any error so that we don't break any execution path\r\n        }\r\n    }\r\n    return result;\r\n}\r\n/**\r\n * Removes an event handler for the specified event\r\n * @param Object - to remove the event from\r\n * @param eventName - {string} - The name of the event, with optional namespaces or just the namespaces,\r\n * such as \"click\", \"click.mynamespace\" or \".mynamespace\"\r\n * @param handlerRef - {any} - The callback function that needs to be removed from the given event, when using a\r\n * namespace (with or without a qualifying event) this may be null to remove all previously attached event handlers\r\n * otherwise this will only remove events with this specific handler.\r\n * @param evtNamespace - [Optional] Additional namespace(s) to append to the event listeners so they can be uniquely identified and removed based on this namespace,\r\n * if the eventName also includes a namespace the namespace(s) are merged into a single namespace\r\n * @param useCapture - [Optional] Defaults to false\r\n */\r\nexport function eventOff(target, eventName, handlerRef, evtNamespace, useCapture) {\r\n    if (useCapture === void 0) { useCapture = false; }\r\n    if (target) {\r\n        try {\r\n            var evtName_1 = _getEvtNamespace(eventName, evtNamespace);\r\n            var found_1 = false;\r\n            _unregisterEvents(target, evtName_1, function (regEvent) {\r\n                if ((evtName_1.ns && !handlerRef) || regEvent[_DYN_HANDLER /* @min:%2ehandler */] === handlerRef) {\r\n                    found_1 = true;\r\n                    return true;\r\n                }\r\n                return false;\r\n            });\r\n            if (!found_1) {\r\n                // fallback to try and remove as requested\r\n                _doDetach(target, evtName_1, handlerRef, useCapture);\r\n            }\r\n        }\r\n        catch (e) {\r\n            // Just Ignore any error so that we don't break any execution path\r\n        }\r\n    }\r\n}\r\n/**\r\n * Binds the specified function to an event, so that the function gets called whenever the event fires on the object\r\n * @param obj - Object to add the event too.\r\n * @param eventNameWithoutOn - String that specifies any of the standard DHTML Events without \"on\" prefix and optional (dot \".\" prefixed) namespaces \"click\" \"click.mynamespace\".\r\n * @param handlerRef - Pointer that specifies the function to call when event fires\r\n * @param useCapture - [Optional] Defaults to false\r\n * @returns True if the function was bound successfully to the event, otherwise false\r\n */\r\nexport function attachEvent(obj, eventNameWithoutOn, handlerRef, useCapture) {\r\n    if (useCapture === void 0) { useCapture = false; }\r\n    return eventOn(obj, eventNameWithoutOn, handlerRef, null, useCapture);\r\n}\r\n/**\r\n * Removes an event handler for the specified event\r\n * @param Object - to remove the event from\r\n * @param eventNameWithoutOn - {string} - The name of the event, with optional namespaces or just the namespaces,\r\n * such as \"click\", \"click.mynamespace\" or \".mynamespace\"\r\n * @param handlerRef - {any} - The callback function that needs to be removed from the given event, when using a\r\n * namespace (with or without a qualifying event) this may be null to remove all previously attached event handlers\r\n * otherwise this will only remove events with this specific handler.\r\n * @param useCapture - [Optional] Defaults to false\r\n */\r\nexport function detachEvent(obj, eventNameWithoutOn, handlerRef, useCapture) {\r\n    if (useCapture === void 0) { useCapture = false; }\r\n    eventOff(obj, eventNameWithoutOn, handlerRef, null, useCapture);\r\n}\r\n/**\r\n * Trys to add an event handler for the specified event to the window, body and document\r\n * @param eventName - {string} - The name of the event\r\n * @param callback - {any} - The callback function that needs to be executed for the given event\r\n * @param evtNamespace - [Optional] Namespace(s) to append to the event listeners so they can be uniquely identified and removed based on this namespace.\r\n * @return {boolean} - true if the handler was successfully added\r\n */\r\nexport function addEventHandler(eventName, callback, evtNamespace) {\r\n    var result = false;\r\n    var w = getWindow();\r\n    if (w) {\r\n        result = eventOn(w, eventName, callback, evtNamespace);\r\n        result = eventOn(w[\"body\"], eventName, callback, evtNamespace) || result;\r\n    }\r\n    var doc = getDocument();\r\n    if (doc) {\r\n        result = eventOn(doc, eventName, callback, evtNamespace) || result;\r\n    }\r\n    return result;\r\n}\r\n/**\r\n * Trys to remove event handler(s) for the specified event/namespace to the window, body and document\r\n * @param eventName - {string} - The name of the event, with optional namespaces or just the namespaces,\r\n * such as \"click\", \"click.mynamespace\" or \".mynamespace\"\r\n * @param callback - {any} - - The callback function that needs to be removed from the given event, when using a\r\n * namespace (with or without a qualifying event) this may be null to remove all previously attached event handlers\r\n * otherwise this will only remove events with this specific handler.\r\n * @param evtNamespace - [Optional] Namespace(s) to append to the event listeners so they can be uniquely identified and removed based on this namespace.\r\n */\r\nexport function removeEventHandler(eventName, callback, evtNamespace) {\r\n    var w = getWindow();\r\n    if (w) {\r\n        eventOff(w, eventName, callback, evtNamespace);\r\n        eventOff(w[\"body\"], eventName, callback, evtNamespace);\r\n    }\r\n    var doc = getDocument();\r\n    if (doc) {\r\n        eventOff(doc, eventName, callback, evtNamespace);\r\n    }\r\n}\r\n/**\r\n * Bind the listener to the array of events\r\n * @param events - An string array of event names to bind the listener to\r\n * @param listener - The event callback to call when the event is triggered\r\n * @param excludeEvents - [Optional] An array of events that should not be hooked (if possible), unless no other events can be.\r\n * @param evtNamespace - [Optional] Namespace(s) to append to the event listeners so they can be uniquely identified and removed based on this namespace.\r\n * @returns true - when at least one of the events was registered otherwise false\r\n */\r\nfunction _addEventListeners(events, listener, excludeEvents, evtNamespace) {\r\n    var added = false;\r\n    if (listener && events && events[_DYN_LENGTH /* @min:%2elength */] > 0) {\r\n        arrForEach(events, function (name) {\r\n            if (name) {\r\n                if (!excludeEvents || arrIndexOf(excludeEvents, name) === -1) {\r\n                    added = addEventHandler(name, listener, evtNamespace) || added;\r\n                }\r\n            }\r\n        });\r\n    }\r\n    return added;\r\n}\r\n/**\r\n * Bind the listener to the array of events\r\n * @param events - An string array of event names to bind the listener to\r\n * @param listener - The event callback to call when the event is triggered\r\n * @param excludeEvents - [Optional] An array of events that should not be hooked (if possible), unless no other events can be.\r\n * @param evtNamespace - [Optional] Namespace(s) to append to the event listeners so they can be uniquely identified and removed based on this namespace.\r\n * @returns true - when at least one of the events was registered otherwise false\r\n */\r\nexport function addEventListeners(events, listener, excludeEvents, evtNamespace) {\r\n    var added = false;\r\n    if (listener && events && isArray(events)) {\r\n        added = _addEventListeners(events, listener, excludeEvents, evtNamespace);\r\n        if (!added && excludeEvents && excludeEvents[_DYN_LENGTH /* @min:%2elength */] > 0) {\r\n            // Failed to add any listeners and we excluded some, so just attempt to add the excluded events\r\n            added = _addEventListeners(events, listener, null, evtNamespace);\r\n        }\r\n    }\r\n    return added;\r\n}\r\n/**\r\n * Remove the listener from the array of events\r\n * @param events - An string array of event names to bind the listener to\r\n * @param listener - The event callback to call when the event is triggered\r\n * @param evtNamespace - [Optional] Namespace(s) to append to the event listeners so they can be uniquely identified and removed based on this namespace.\r\n */\r\nexport function removeEventListeners(events, listener, evtNamespace) {\r\n    if (events && isArray(events)) {\r\n        arrForEach(events, function (name) {\r\n            if (name) {\r\n                removeEventHandler(name, listener, evtNamespace);\r\n            }\r\n        });\r\n    }\r\n}\r\n/**\r\n * Listen to the 'beforeunload', 'unload' and 'pagehide' events which indicates a page unload is occurring,\r\n * this does NOT listen to the 'visibilitychange' event as while it does indicate that the page is being hidden\r\n * it does not *necessarily* mean that the page is being completely unloaded, it can mean that the user is\r\n * just navigating to a different Tab and may come back (without unloading the page). As such you may also\r\n * need to listen to the 'addPageHideEventListener' and 'addPageShowEventListener' events.\r\n * @param listener - The event callback to call when a page unload event is triggered\r\n * @param excludeEvents - [Optional] An array of events that should not be hooked, unless no other events can be.\r\n * @param evtNamespace - [Optional] Namespace(s) to append to the event listeners so they can be uniquely identified and removed based on this namespace.\r\n * @returns true - when at least one of the events was registered otherwise false\r\n */\r\nexport function addPageUnloadEventListener(listener, excludeEvents, evtNamespace) {\r\n    // Hook the unload event for the document, window and body to ensure that the client events are flushed to the server\r\n    // As just hooking the window does not always fire (on chrome) for page navigation's.\r\n    return addEventListeners([strBeforeUnload, strUnload, strPageHide], listener, excludeEvents, evtNamespace);\r\n}\r\n/**\r\n * Remove any matching 'beforeunload', 'unload' and 'pagehide' events that may have been added via addEventListener,\r\n * addEventListeners, addPageUnloadEventListener or addPageHideEventListener.\r\n * @param listener - The specific event callback to to be removed\r\n * @param evtNamespace - [Optional] Namespace(s) uniquely identified and removed based on this namespace.\r\n * @returns true - when at least one of the events was registered otherwise false\r\n */\r\nexport function removePageUnloadEventListener(listener, evtNamespace) {\r\n    removeEventListeners([strBeforeUnload, strUnload, strPageHide], listener, evtNamespace);\r\n}\r\n/**\r\n * Listen to the pagehide and visibility changing to 'hidden' events, because the 'visibilitychange' uses\r\n * an internal proxy to detect the visibility state you SHOULD use a unique namespace when if you plan to call\r\n * removePageShowEventListener as the remove ignores the listener argument for the 'visibilitychange' event.\r\n * @param listener - The event callback to call when a page hide event is triggered\r\n * @param excludeEvents - [Optional] An array of events that should not be hooked (if possible), unless no other events can be.\r\n * @param evtNamespace - [Optional] A Namespace to append to the event listeners so they can be uniquely identified and removed\r\n * based on this namespace. This call also adds an additional unique \"pageshow\" namespace to the events\r\n * so that only the matching \"removePageHideEventListener\" can remove these events.\r\n * Suggestion: pass as true if you are also calling addPageUnloadEventListener as that also hooks pagehide\r\n * @returns true - when at least one of the events was registered otherwise false\r\n */\r\nexport function addPageHideEventListener(listener, excludeEvents, evtNamespace) {\r\n    function _handlePageVisibility(evt) {\r\n        var doc = getDocument();\r\n        if (listener && doc && doc.visibilityState === \"hidden\") {\r\n            listener(evt);\r\n        }\r\n    }\r\n    // add the unique page show namespace to any provided namespace so we can only remove the ones added by \"pagehide\"\r\n    var newNamespaces = mergeEvtNamespace(strPageHideNamespace, evtNamespace);\r\n    var pageUnloadAdded = _addEventListeners([strPageHide], listener, excludeEvents, newNamespaces);\r\n    if (!excludeEvents || arrIndexOf(excludeEvents, strVisibilityChangeEvt) === -1) {\r\n        pageUnloadAdded = _addEventListeners([strVisibilityChangeEvt], _handlePageVisibility, excludeEvents, newNamespaces) || pageUnloadAdded;\r\n    }\r\n    if (!pageUnloadAdded && excludeEvents) {\r\n        // Failed to add any listeners and we where requested to exclude some, so just call again without excluding anything\r\n        pageUnloadAdded = addPageHideEventListener(listener, null, evtNamespace);\r\n    }\r\n    return pageUnloadAdded;\r\n}\r\n/**\r\n * Removes the pageHide event listeners added by addPageHideEventListener, because the 'visibilitychange' uses\r\n * an internal proxy to detect the visibility state you SHOULD use a unique namespace when calling addPageHideEventListener\r\n * as the remove ignores the listener argument for the 'visibilitychange' event.\r\n * @param listener - The specific listener to remove for the 'pageshow' event only (ignored for 'visibilitychange')\r\n * @param evtNamespace - The unique namespace used when calling addPageShowEventListener\r\n */\r\nexport function removePageHideEventListener(listener, evtNamespace) {\r\n    // add the unique page show namespace to any provided namespace so we only remove the ones added by \"pagehide\"\r\n    var newNamespaces = mergeEvtNamespace(strPageHideNamespace, evtNamespace);\r\n    removeEventListeners([strPageHide], listener, newNamespaces);\r\n    removeEventListeners([strVisibilityChangeEvt], null, newNamespaces);\r\n}\r\n/**\r\n * Listen to the pageshow and visibility changing to 'visible' events, because the 'visibilitychange' uses\r\n * an internal proxy to detect the visibility state you SHOULD use a unique namespace when if you plan to call\r\n * removePageShowEventListener as the remove ignores the listener argument for the 'visibilitychange' event.\r\n * @param listener - The event callback to call when a page is show event is triggered\r\n * @param excludeEvents - [Optional] An array of events that should not be hooked (if possible), unless no other events can be.\r\n * @param evtNamespace - [Optional/Recommended] A Namespace to append to the event listeners so they can be uniquely\r\n * identified and removed based on this namespace. This call also adds an additional unique \"pageshow\" namespace to the events\r\n * so that only the matching \"removePageShowEventListener\" can remove these events.\r\n * @returns true - when at least one of the events was registered otherwise false\r\n */\r\nexport function addPageShowEventListener(listener, excludeEvents, evtNamespace) {\r\n    function _handlePageVisibility(evt) {\r\n        var doc = getDocument();\r\n        if (listener && doc && doc.visibilityState === \"visible\") {\r\n            listener(evt);\r\n        }\r\n    }\r\n    // add the unique page show namespace to any provided namespace so we can only remove the ones added by \"pageshow\"\r\n    var newNamespaces = mergeEvtNamespace(strPageShowNamespace, evtNamespace);\r\n    var pageShowAdded = _addEventListeners([strPageShow], listener, excludeEvents, newNamespaces);\r\n    pageShowAdded = _addEventListeners([strVisibilityChangeEvt], _handlePageVisibility, excludeEvents, newNamespaces) || pageShowAdded;\r\n    if (!pageShowAdded && excludeEvents) {\r\n        // Failed to add any listeners and we where requested to exclude some, so just call again without excluding anything\r\n        pageShowAdded = addPageShowEventListener(listener, null, evtNamespace);\r\n    }\r\n    return pageShowAdded;\r\n}\r\n/**\r\n * Removes the pageShow event listeners added by addPageShowEventListener, because the 'visibilitychange' uses\r\n * an internal proxy to detect the visibility state you SHOULD use a unique namespace when calling addPageShowEventListener\r\n * as the remove ignores the listener argument for the 'visibilitychange' event.\r\n * @param listener - The specific listener to remove for the 'pageshow' event only (ignored for 'visibilitychange')\r\n * @param evtNamespace - The unique namespace used when calling addPageShowEventListener\r\n */\r\nexport function removePageShowEventListener(listener, evtNamespace) {\r\n    // add the unique page show namespace to any provided namespace so we only remove the ones added by \"pageshow\"\r\n    var newNamespaces = mergeEvtNamespace(strPageShowNamespace, evtNamespace);\r\n    removeEventListeners([strPageShow], listener, newNamespaces);\r\n    removeEventListeners([strVisibilityChangeEvt], null, newNamespaces);\r\n}\r\n//# sourceMappingURL=EventHelpers.js.map","// Copyright (c) Microsoft Corporation. All rights reserved.\r\n// Licensed under the MIT License.\r\n\"use strict\";\r\nvar _a;\r\nimport dynamicProto from \"@microsoft/dynamicproto-js\";\r\nimport { AnalyticsPlugin } from \"@microsoft/applicationinsights-analytics-js\";\r\nimport { Sender } from \"@microsoft/applicationinsights-channel-js\";\r\nimport { DEFAULT_BREEZE_PATH, PropertiesPluginIdentifier, parseConnectionString } from \"@microsoft/applicationinsights-common\";\r\nimport { AppInsightsCore, _throwInternal, addPageHideEventListener, addPageUnloadEventListener, cfgDfValidate, createDynamicConfig, createUniqueNamespace, doPerf, hasDocument, hasWindow, isArray, isFunction, isNullOrUndefined, isReactNative, isString, mergeEvtNamespace, onConfigChange, proxyAssign, proxyFunctions, removePageHideEventListener, removePageUnloadEventListener } from \"@microsoft/applicationinsights-core-js\";\r\nimport { AjaxPlugin as DependenciesPlugin } from \"@microsoft/applicationinsights-dependencies-js\";\r\nimport { PropertiesPlugin } from \"@microsoft/applicationinsights-properties-js\";\r\nimport { createPromise } from \"@nevware21/ts-async\";\r\nimport { arrForEach, arrIndexOf, objDefine, objForEachKey, strIndexOf, throwUnsupported } from \"@nevware21/ts-utils\";\r\nimport { STR_ADD_TELEMETRY_INITIALIZER, STR_CLEAR_AUTHENTICATED_USER_CONTEXT, STR_EVT_NAMESPACE, STR_FLUSH, STR_GET_COOKIE_MGR, STR_GET_PLUGIN, STR_POLL_INTERNAL_LOGS, STR_SET_AUTHENTICATED_USER_CONTEXT, STR_SNIPPET, STR_START_TRACK_EVENT, STR_START_TRACK_PAGE, STR_STOP_TRACK_EVENT, STR_STOP_TRACK_PAGE, STR_TRACK_DEPENDENCY_DATA, STR_TRACK_EVENT, STR_TRACK_EXCEPTION, STR_TRACK_METRIC, STR_TRACK_PAGE_VIEW, STR_TRACK_TRACE } from \"./InternalConstants\";\r\nimport { _DYN_ADD_HOUSEKEEPING_BEF1, _DYN_CONNECTION_STRING, _DYN_CONTEXT, _DYN_DISABLE_IKEY_DEPRECA0, _DYN_ENDPOINT_URL, _DYN_INSTRUMENTATION_KEY, _DYN_ONUNLOAD_FLUSH, _DYN_QUEUE, _DYN_UPDATE_SNIPPET_DEFIN2, _DYN_VERSION } from \"./__DynamicConstants\";\r\nvar _internalSdkSrc;\r\n// This is an exclude list of properties that should not be updated during initialization\r\n// They include a combination of private and internal property names\r\nvar _ignoreUpdateSnippetProperties = [\r\n    STR_SNIPPET, \"dependencies\", \"properties\", \"_snippetVersion\", \"appInsightsNew\", \"getSKUDefaults\"\r\n];\r\nvar UNDEFINED_VALUE = undefined;\r\n// We need to include all properties that we only reference that we want to be dynamically updatable here\r\n// So they are converted even when not specified in the passed configuration\r\nvar defaultConfigValues = (_a = {},\r\n    _a[_DYN_CONNECTION_STRING /* @min:connectionString */] = UNDEFINED_VALUE,\r\n    _a[_DYN_ENDPOINT_URL /* @min:endpointUrl */] = UNDEFINED_VALUE,\r\n    _a[_DYN_INSTRUMENTATION_KEY /* @min:instrumentationKey */] = UNDEFINED_VALUE,\r\n    _a.diagnosticLogInterval = cfgDfValidate(_chkDiagLevel, 10000),\r\n    _a);\r\nfunction _chkDiagLevel(value) {\r\n    // Make sure we have a value > 0\r\n    return value && value > 0;\r\n}\r\n/**\r\n * Application Insights API\r\n * @class Initialization\r\n * @implements {IApplicationInsights}\r\n */\r\nvar AppInsightsSku = /** @class */ (function () {\r\n    function AppInsightsSku(snippet) {\r\n        var _this = this;\r\n        // NOTE!: DON'T set default values here, instead set them in the _initDefaults() function as it is also called during teardown()\r\n        var dependencies;\r\n        var properties;\r\n        var _sender;\r\n        var _snippetVersion;\r\n        var _evtNamespace;\r\n        var _houseKeepingNamespace;\r\n        var _core;\r\n        var _config;\r\n        var _analyticsPlugin;\r\n        dynamicProto(AppInsightsSku, this, function (_self) {\r\n            _initDefaults();\r\n            objDefine(_self, \"config\", {\r\n                g: function () {\r\n                    return _config;\r\n                }\r\n            });\r\n            arrForEach([\"pluginVersionStringArr\", \"pluginVersionString\"], function (key) {\r\n                objDefine(_self, key, {\r\n                    g: function () {\r\n                        if (_core) {\r\n                            return _core[key];\r\n                        }\r\n                        return null;\r\n                    }\r\n                });\r\n            });\r\n            // initialize the queue and config in case they are undefined\r\n            _snippetVersion = \"\" + (snippet.sv || snippet[_DYN_VERSION /* @min:%2eversion */] || \"\");\r\n            snippet[_DYN_QUEUE /* @min:%2equeue */] = snippet[_DYN_QUEUE /* @min:%2equeue */] || [];\r\n            snippet[_DYN_VERSION /* @min:%2eversion */] = snippet[_DYN_VERSION /* @min:%2eversion */] || 2.0; // Default to new version\r\n            var cfgHandler = createDynamicConfig(snippet.config || {}, defaultConfigValues);\r\n            _config = cfgHandler.cfg;\r\n            _analyticsPlugin = new AnalyticsPlugin();\r\n            objDefine(_self, \"appInsights\", {\r\n                g: function () {\r\n                    return _analyticsPlugin;\r\n                }\r\n            });\r\n            properties = new PropertiesPlugin();\r\n            dependencies = new DependenciesPlugin();\r\n            _sender = new Sender();\r\n            _core = new AppInsightsCore();\r\n            objDefine(_self, \"core\", {\r\n                g: function () {\r\n                    return _core;\r\n                }\r\n            });\r\n            // Will get recalled if any referenced values are changed\r\n            _addUnloadHook(onConfigChange(cfgHandler, function () {\r\n                if (_config[_DYN_CONNECTION_STRING /* @min:%2econnectionString */]) {\r\n                    var cs = parseConnectionString(_config[_DYN_CONNECTION_STRING /* @min:%2econnectionString */]);\r\n                    var ingest = cs.ingestionendpoint;\r\n                    _config[_DYN_ENDPOINT_URL /* @min:%2eendpointUrl */] = ingest ? (ingest + DEFAULT_BREEZE_PATH) : _config[_DYN_ENDPOINT_URL /* @min:%2eendpointUrl */]; // only add /v2/track when from connectionstring\r\n                    _config[_DYN_INSTRUMENTATION_KEY /* @min:%2einstrumentationKey */] = cs.instrumentationkey || _config[_DYN_INSTRUMENTATION_KEY /* @min:%2einstrumentationKey */];\r\n                }\r\n            }));\r\n            // Outside of the onConfigChange as we only want to do this once\r\n            var isErrMessageDisabled = isNullOrUndefined(_config[_DYN_DISABLE_IKEY_DEPRECA0 /* @min:%2edisableIkeyDeprecationMessage */]) ? true : _config[_DYN_DISABLE_IKEY_DEPRECA0 /* @min:%2edisableIkeyDeprecationMessage */];\r\n            if (!_config[_DYN_CONNECTION_STRING /* @min:%2econnectionString */] && !isErrMessageDisabled) {\r\n                _throwInternal(_core.logger, 1 /* eLoggingSeverity.CRITICAL */, 106 /* _eInternalMessageId.InstrumentationKeyDeprecation */, \"Instrumentation key support will end soon, see aka.ms/IkeyMigrate\");\r\n            }\r\n            _self[STR_SNIPPET /* @min:%2esnippet */] = snippet;\r\n            _self[STR_FLUSH /* @min:%2eflush */] = function (async, callBack) {\r\n                if (async === void 0) { async = true; }\r\n                var result;\r\n                doPerf(_core, function () { return \"AISKU.flush\"; }, function () {\r\n                    if (async && !callBack) {\r\n                        result = createPromise(function (resolve) {\r\n                            callBack = resolve;\r\n                        });\r\n                    }\r\n                    var waiting = 1;\r\n                    var flushDone = function () {\r\n                        waiting--;\r\n                        if (waiting === 0) {\r\n                            callBack();\r\n                        }\r\n                    };\r\n                    arrForEach(_core.getChannels(), function (channel) {\r\n                        if (channel) {\r\n                            waiting++;\r\n                            channel[STR_FLUSH /* @min:%2eflush */](async, flushDone);\r\n                        }\r\n                    });\r\n                    // decrement the initial \"waiting\"\r\n                    flushDone();\r\n                }, null, async);\r\n                return result;\r\n            };\r\n            _self[_DYN_ONUNLOAD_FLUSH /* @min:%2eonunloadFlush */] = function (async) {\r\n                if (async === void 0) { async = true; }\r\n                arrForEach(_core.getChannels(), function (channel) {\r\n                    if (channel[_DYN_ONUNLOAD_FLUSH /* @min:%2eonunloadFlush */]) {\r\n                        channel[_DYN_ONUNLOAD_FLUSH /* @min:%2eonunloadFlush */]();\r\n                    }\r\n                    else {\r\n                        channel[STR_FLUSH /* @min:%2eflush */](async);\r\n                    }\r\n                });\r\n            };\r\n            _self.loadAppInsights = function (legacyMode, logger, notificationManager) {\r\n                if (legacyMode === void 0) { legacyMode = false; }\r\n                if (legacyMode) {\r\n                    throwUnsupported(\"Legacy Mode is no longer supported\");\r\n                }\r\n                function _updateSnippetProperties(snippet) {\r\n                    if (snippet) {\r\n                        var snippetVer = \"\";\r\n                        if (!isNullOrUndefined(_snippetVersion)) {\r\n                            snippetVer += _snippetVersion;\r\n                        }\r\n                        if (_self[_DYN_CONTEXT /* @min:%2econtext */] && _self[_DYN_CONTEXT /* @min:%2econtext */].internal) {\r\n                            _self[_DYN_CONTEXT /* @min:%2econtext */].internal.snippetVer = snippetVer || \"-\";\r\n                        }\r\n                        // apply updated properties to the global instance (snippet)\r\n                        objForEachKey(_self, function (field, value) {\r\n                            if (isString(field) &&\r\n                                !isFunction(value) &&\r\n                                field && field[0] !== \"_\" && // Don't copy \"internal\" values\r\n                                arrIndexOf(_ignoreUpdateSnippetProperties, field) === -1) {\r\n                                if (snippet[field] !== value) {\r\n                                    snippet[field] = value;\r\n                                }\r\n                            }\r\n                        });\r\n                    }\r\n                }\r\n                doPerf(_self.core, function () { return \"AISKU.loadAppInsights\"; }, function () {\r\n                    // initialize core\r\n                    _core.initialize(_config, [_sender, properties, dependencies, _analyticsPlugin], logger, notificationManager);\r\n                    objDefine(_self, \"context\", {\r\n                        g: function () { return properties[_DYN_CONTEXT /* @min:%2econtext */]; }\r\n                    });\r\n                    var sdkSrc = _findSdkSourceFile();\r\n                    if (sdkSrc && _self[_DYN_CONTEXT /* @min:%2econtext */]) {\r\n                        _self[_DYN_CONTEXT /* @min:%2econtext */].internal.sdkSrc = sdkSrc;\r\n                    }\r\n                    _updateSnippetProperties(_self[STR_SNIPPET /* @min:%2esnippet */]);\r\n                    // Empty queue of all api calls logged prior to sdk download\r\n                    _self.emptyQueue();\r\n                    _self[STR_POLL_INTERNAL_LOGS /* @min:%2epollInternalLogs */]();\r\n                    _self[_DYN_ADD_HOUSEKEEPING_BEF1 /* @min:%2eaddHousekeepingBeforeUnload */](_self);\r\n                });\r\n                return _self;\r\n            };\r\n            _self[_DYN_UPDATE_SNIPPET_DEFIN2 /* @min:%2eupdateSnippetDefinitions */] = function (snippet) {\r\n                // apply full appInsights to the global instance\r\n                // Note: This must be called before loadAppInsights is called\r\n                proxyAssign(snippet, _self, function (name) {\r\n                    // Not excluding names prefixed with \"_\" as we need to proxy some functions like _onError\r\n                    return name && arrIndexOf(_ignoreUpdateSnippetProperties, name) === -1;\r\n                });\r\n            };\r\n            _self.emptyQueue = function () {\r\n                // call functions that were queued before the main script was loaded\r\n                try {\r\n                    if (isArray(_self.snippet[_DYN_QUEUE /* @min:%2equeue */])) {\r\n                        // note: do not check length in the for-loop conditional in case something goes wrong and the stub methods are not overridden.\r\n                        var length_1 = _self.snippet[_DYN_QUEUE /* @min:%2equeue */].length;\r\n                        for (var i = 0; i < length_1; i++) {\r\n                            var call = _self.snippet[_DYN_QUEUE /* @min:%2equeue */][i];\r\n                            call();\r\n                        }\r\n                        _self.snippet[_DYN_QUEUE /* @min:%2equeue */] = undefined;\r\n                        delete _self.snippet[_DYN_QUEUE /* @min:%2equeue */];\r\n                    }\r\n                }\r\n                catch (exception) {\r\n                    var properties_1 = {};\r\n                    if (exception && isFunction(exception.toString)) {\r\n                        properties_1.exception = exception.toString();\r\n                    }\r\n                    // need from core\r\n                    // Microsoft.ApplicationInsights._InternalLogging.throwInternal(\r\n                    //     eLoggingSeverity.WARNING,\r\n                    //     _eInternalMessageId.FailedToSendQueuedTelemetry,\r\n                    //     \"Failed to send queued telemetry\",\r\n                    //     properties);\r\n                }\r\n            };\r\n            _self[_DYN_ADD_HOUSEKEEPING_BEF1 /* @min:%2eaddHousekeepingBeforeUnload */] = function (appInsightsInstance) {\r\n                // Add callback to push events when the user navigates away\r\n                if (hasWindow() || hasDocument()) {\r\n                    var performHousekeeping_1 = function () {\r\n                        // Adds the ability to flush all data before the page unloads.\r\n                        // Note: This approach tries to push a sync request with all the pending events onbeforeunload.\r\n                        // Firefox does not respect this.Other browsers DO push out the call with < 100% hit rate.\r\n                        // Telemetry here will help us analyze how effective this approach is.\r\n                        // Another approach would be to make this call sync with a acceptable timeout to reduce the\r\n                        // impact on user experience.\r\n                        // appInsightsInstance.context._sender.triggerSend();\r\n                        appInsightsInstance[_DYN_ONUNLOAD_FLUSH /* @min:%2eonunloadFlush */](false);\r\n                        // Back up the current session to local storage\r\n                        // This lets us close expired sessions after the cookies themselves expire\r\n                        if (isFunction(_self.core[STR_GET_PLUGIN /* @min:%2egetPlugin */])) {\r\n                            var loadedPlugin = _this.core[STR_GET_PLUGIN /* @min:%2egetPlugin */](PropertiesPluginIdentifier);\r\n                            if (loadedPlugin) {\r\n                                var propertiesPlugin = loadedPlugin.plugin;\r\n                                if (propertiesPlugin && propertiesPlugin[_DYN_CONTEXT /* @min:%2econtext */] && propertiesPlugin[_DYN_CONTEXT /* @min:%2econtext */]._sessionManager) {\r\n                                    propertiesPlugin[_DYN_CONTEXT /* @min:%2econtext */]._sessionManager.backup();\r\n                                }\r\n                            }\r\n                        }\r\n                    };\r\n                    var added_1 = false;\r\n                    var analyticsPlugin_1 = appInsightsInstance.appInsights;\r\n                    var theConfig_1 = analyticsPlugin_1.config;\r\n                    if (!_houseKeepingNamespace) {\r\n                        _houseKeepingNamespace = mergeEvtNamespace(_evtNamespace, _core[STR_EVT_NAMESPACE /* @min:%2eevtNamespace */] && _core[STR_EVT_NAMESPACE /* @min:%2eevtNamespace */]());\r\n                    }\r\n                    // Will be recalled if any referenced config properties change\r\n                    _addUnloadHook(onConfigChange(_config, function () {\r\n                        // As we could get recalled, remove any previously registered event handlers first\r\n                        _removePageEventHandlers();\r\n                        var excludePageUnloadEvents = theConfig_1.disablePageUnloadEvents;\r\n                        if (!theConfig_1.disableFlushOnBeforeUnload) {\r\n                            // Hook the unload event for the document, window and body to ensure that the client events are flushed to the server\r\n                            // As just hooking the window does not always fire (on chrome) for page navigation's.\r\n                            if (addPageUnloadEventListener(performHousekeeping_1, excludePageUnloadEvents, _houseKeepingNamespace)) {\r\n                                added_1 = true;\r\n                            }\r\n                            // We also need to hook the pagehide and visibilitychange events as not all versions of Safari support load/unload events.\r\n                            if (addPageHideEventListener(performHousekeeping_1, excludePageUnloadEvents, _houseKeepingNamespace)) {\r\n                                added_1 = true;\r\n                            }\r\n                            // A reactNative app may not have a window and therefore the beforeunload/pagehide events -- so don't\r\n                            // log the failure in this case\r\n                            if (!added_1 && !isReactNative()) {\r\n                                _throwInternal(analyticsPlugin_1.core.logger, 1 /* eLoggingSeverity.CRITICAL */, 19 /* _eInternalMessageId.FailedToAddHandlerForOnBeforeUnload */, \"Could not add handler for beforeunload and pagehide\");\r\n                            }\r\n                        }\r\n                        if (!added_1 && !theConfig_1.disableFlushOnUnload) {\r\n                            // If we didn't add the normal set then attempt to add the pagehide and visibilitychange only\r\n                            addPageHideEventListener(performHousekeeping_1, excludePageUnloadEvents, _houseKeepingNamespace);\r\n                        }\r\n                    }));\r\n                }\r\n            };\r\n            _self.getSender = function () {\r\n                return _sender;\r\n            };\r\n            _self.unload = function (isAsync, unloadComplete, cbTimeout) {\r\n                var unloadDone = false;\r\n                var result;\r\n                if (isAsync && !unloadComplete) {\r\n                    result = createPromise(function (resolve) {\r\n                        // Set the callback to the promise resolve callback\r\n                        unloadComplete = resolve;\r\n                    });\r\n                }\r\n                function _unloadCallback(unloadState) {\r\n                    if (!unloadDone) {\r\n                        unloadDone = true;\r\n                        _initDefaults();\r\n                        unloadComplete && unloadComplete(unloadState);\r\n                    }\r\n                }\r\n                _self[_DYN_ONUNLOAD_FLUSH /* @min:%2eonunloadFlush */](isAsync);\r\n                _removePageEventHandlers();\r\n                _core.unload && _core.unload(isAsync, _unloadCallback, cbTimeout);\r\n                return result;\r\n            };\r\n            proxyFunctions(_self, _analyticsPlugin, [\r\n                STR_GET_COOKIE_MGR,\r\n                STR_TRACK_EVENT,\r\n                STR_TRACK_PAGE_VIEW,\r\n                \"trackPageViewPerformance\",\r\n                STR_TRACK_EXCEPTION,\r\n                \"_onerror\",\r\n                STR_TRACK_TRACE,\r\n                STR_TRACK_METRIC,\r\n                STR_START_TRACK_PAGE,\r\n                STR_STOP_TRACK_PAGE,\r\n                STR_START_TRACK_EVENT,\r\n                STR_STOP_TRACK_EVENT\r\n            ]);\r\n            proxyFunctions(_self, _getCurrentDependencies, [\r\n                STR_TRACK_DEPENDENCY_DATA,\r\n                \"addDependencyListener\",\r\n                \"addDependencyInitializer\"\r\n            ]);\r\n            proxyFunctions(_self, _core, [\r\n                STR_ADD_TELEMETRY_INITIALIZER,\r\n                STR_POLL_INTERNAL_LOGS,\r\n                \"stopPollingInternalLogs\",\r\n                STR_GET_PLUGIN,\r\n                \"addPlugin\",\r\n                STR_EVT_NAMESPACE,\r\n                \"addUnloadCb\",\r\n                \"getTraceCtx\",\r\n                \"updateCfg\",\r\n                \"onCfgChange\"\r\n            ]);\r\n            proxyFunctions(_self, function () {\r\n                var context = properties[_DYN_CONTEXT /* @min:%2econtext */];\r\n                return context ? context.user : null;\r\n            }, [\r\n                STR_SET_AUTHENTICATED_USER_CONTEXT,\r\n                STR_CLEAR_AUTHENTICATED_USER_CONTEXT\r\n            ]);\r\n            // Using a function to support the dynamic adding / removal of plugins, so this will always return the current value\r\n            function _getCurrentDependencies() {\r\n                return dependencies;\r\n            }\r\n            function _initDefaults() {\r\n                _evtNamespace = createUniqueNamespace(\"AISKU\");\r\n                _houseKeepingNamespace = null;\r\n                dependencies = null;\r\n                properties = null;\r\n                _sender = null;\r\n                _snippetVersion = null;\r\n            }\r\n            function _removePageEventHandlers() {\r\n                // Remove any registered event handlers\r\n                if (_houseKeepingNamespace) {\r\n                    removePageUnloadEventListener(null, _houseKeepingNamespace);\r\n                    removePageHideEventListener(null, _houseKeepingNamespace);\r\n                }\r\n            }\r\n            function _addUnloadHook(hooks) {\r\n                _core.addUnloadHook(hooks);\r\n            }\r\n        });\r\n    }\r\n    // Analytics Plugin\r\n    /**\r\n     * Get the current cookie manager for this instance\r\n     */\r\n    AppInsightsSku.prototype.getCookieMgr = function () {\r\n        // @DynamicProtoStub -- DO NOT add any code as this will be removed during packaging\r\n        return null;\r\n    };\r\n    /**\r\n     * Log a user action or other occurrence.\r\n     * @param event\r\n     * @param [customProperties]\r\n     * @memberof Initialization\r\n     */\r\n    AppInsightsSku.prototype.trackEvent = function (event, customProperties) {\r\n        // @DynamicProtoStub -- DO NOT add any code as this will be removed during packaging\r\n    };\r\n    /**\r\n     * Logs that a page, or similar container was displayed to the user.\r\n     * @param pageView\r\n     * @memberof Initialization\r\n     */\r\n    AppInsightsSku.prototype.trackPageView = function (pageView) {\r\n        // @DynamicProtoStub -- DO NOT add any code as this will be removed during packaging\r\n    };\r\n    /**\r\n     * Log a bag of performance information via the customProperties field.\r\n     * @param pageViewPerformance\r\n     * @memberof Initialization\r\n     */\r\n    AppInsightsSku.prototype.trackPageViewPerformance = function (pageViewPerformance) {\r\n        // @DynamicProtoStub -- DO NOT add any code as this will be removed during packaging\r\n    };\r\n    /**\r\n     * Log an exception that you have caught.\r\n     * @param exception\r\n     * @param } customProperties   Additional data used to filter pages and metrics in the portal. Defaults to empty.\r\n     * @memberof Initialization\r\n     */\r\n    AppInsightsSku.prototype.trackException = function (exception, customProperties) {\r\n        // @DynamicProtoStub -- DO NOT add any code as this will be removed during packaging\r\n    };\r\n    /**\r\n     * Manually send uncaught exception telemetry. This method is automatically triggered\r\n     * on a window.onerror event.\r\n     * @param exception\r\n     * @memberof Initialization\r\n     */\r\n    AppInsightsSku.prototype._onerror = function (exception) {\r\n        // @DynamicProtoStub -- DO NOT add any code as this will be removed during packaging\r\n    };\r\n    /**\r\n     * Log a diagnostic scenario such entering or leaving a function.\r\n     * @param trace\r\n     * @param [customProperties]\r\n     * @memberof Initialization\r\n     */\r\n    AppInsightsSku.prototype.trackTrace = function (trace, customProperties) {\r\n        // @DynamicProtoStub -- DO NOT add any code as this will be removed during packaging\r\n    };\r\n    /**\r\n     * Log a numeric value that is not associated with a specific event. Typically used\r\n     * to send regular reports of performance indicators.\r\n     *\r\n     * To send a single measurement, just use the `name` and `average` fields\r\n     * of {@link IMetricTelemetry}.\r\n     *\r\n     * If you take measurements frequently, you can reduce the telemetry bandwidth by\r\n     * aggregating multiple measurements and sending the resulting average and modifying\r\n     * the `sampleCount` field of {@link IMetricTelemetry}.\r\n     * @param metric - input object argument. Only `name` and `average` are mandatory.\r\n     * @param [customProperties]\r\n     * @memberof Initialization\r\n     */\r\n    AppInsightsSku.prototype.trackMetric = function (metric, customProperties) {\r\n        // @DynamicProtoStub -- DO NOT add any code as this will be removed during packaging\r\n    };\r\n    /**\r\n     * Starts the timer for tracking a page load time. Use this instead of `trackPageView` if you want to control when the page view timer starts and stops,\r\n     * but don't want to calculate the duration yourself. This method doesn't send any telemetry. Call `stopTrackPage` to log the end of the page view\r\n     * and send the event.\r\n     * @param name - A string that idenfities this item, unique within this HTML document. Defaults to the document title.\r\n     */\r\n    AppInsightsSku.prototype.startTrackPage = function (name) {\r\n        // @DynamicProtoStub -- DO NOT add any code as this will be removed during packaging\r\n    };\r\n    /**\r\n     * Stops the timer that was started by calling `startTrackPage` and sends the pageview load time telemetry with the specified properties and measurements.\r\n     * The duration of the page view will be the time between calling `startTrackPage` and `stopTrackPage`.\r\n     * @param   name  The string you used as the name in startTrackPage. Defaults to the document title.\r\n     * @param   url   String - a relative or absolute URL that identifies the page or other item. Defaults to the window location.\r\n     * @param   properties  map[string, string] - additional data used to filter pages and metrics in the portal. Defaults to empty.\r\n     * @param   measurements    map[string, number] - metrics associated with this page, displayed in Metrics Explorer on the portal. Defaults to empty.\r\n     */\r\n    AppInsightsSku.prototype.stopTrackPage = function (name, url, customProperties, measurements) {\r\n        // @DynamicProtoStub -- DO NOT add any code as this will be removed during packaging\r\n    };\r\n    AppInsightsSku.prototype.startTrackEvent = function (name) {\r\n        // @DynamicProtoStub -- DO NOT add any code as this will be removed during packaging\r\n    };\r\n    /**\r\n     * Log an extended event that you started timing with `startTrackEvent`.\r\n     * @param   name    The string you used to identify this event in `startTrackEvent`.\r\n     * @param   properties  map[string, string] - additional data used to filter events and metrics in the portal. Defaults to empty.\r\n     * @param   measurements    map[string, number] - metrics associated with this event, displayed in Metrics Explorer on the portal. Defaults to empty.\r\n     */\r\n    AppInsightsSku.prototype.stopTrackEvent = function (name, properties, measurements) {\r\n        // @DynamicProtoStub -- DO NOT add any code as this will be removed during packaging\r\n    };\r\n    AppInsightsSku.prototype.addTelemetryInitializer = function (telemetryInitializer) {\r\n        // @DynamicProtoStub -- DO NOT add any code as this will be removed during packaging\r\n        return null;\r\n    };\r\n    // Properties Plugin\r\n    /**\r\n     * Set the authenticated user id and the account id. Used for identifying a specific signed-in user. Parameters must not contain whitespace or ,;=|\r\n     *\r\n     * The method will only set the `authenticatedUserId` and `accountId` in the current page view. To set them for the whole session, you should set `storeInCookie = true`\r\n     * @param authenticatedUserId\r\n     * @param [accountId]\r\n     * @param [storeInCookie=false]\r\n     */\r\n    AppInsightsSku.prototype.setAuthenticatedUserContext = function (authenticatedUserId, accountId, storeInCookie) {\r\n        if (storeInCookie === void 0) { storeInCookie = false; }\r\n        // @DynamicProtoStub -- DO NOT add any code as this will be removed during packaging\r\n    };\r\n    /**\r\n     * Clears the authenticated user id and account id. The associated cookie is cleared, if present.\r\n     */\r\n    AppInsightsSku.prototype.clearAuthenticatedUserContext = function () {\r\n        // @DynamicProtoStub -- DO NOT add any code as this will be removed during packaging\r\n    };\r\n    // Dependencies Plugin\r\n    /**\r\n     * Log a dependency call (e.g. ajax)\r\n     * @param dependency\r\n     * @memberof Initialization\r\n     */\r\n    AppInsightsSku.prototype.trackDependencyData = function (dependency) {\r\n        // @DynamicProtoStub -- DO NOT add any code as this will be removed during packaging\r\n    };\r\n    // Misc\r\n    /**\r\n     * Attempt to flush data immediately; If executing asynchronously (the default) and\r\n     * you DO NOT pass a callback function then a [IPromise](https://nevware21.github.io/ts-async/typedoc/interfaces/IPromise.html)\r\n     * will be returned which will resolve once the flush is complete. The actual implementation of the `IPromise`\r\n     * will be a native Promise (if supported) or the default as supplied by [ts-async library](https://github.com/nevware21/ts-async)\r\n     * @param async - send data asynchronously when true\r\n     * @param callBack - if specified, notify caller when send is complete, the channel should return true to indicate to the caller that it will be called.\r\n     * If the caller doesn't return true the caller should assume that it may never be called.\r\n     * @returns - If a callback is provided `true` to indicate that callback will be called after the flush is complete otherwise the caller\r\n     * should assume that any provided callback will never be called, Nothing or if occurring asynchronously a\r\n     * [IPromise](https://nevware21.github.io/ts-async/typedoc/interfaces/IPromise.html) which will be resolved once the unload is complete,\r\n     * the [IPromise](https://nevware21.github.io/ts-async/typedoc/interfaces/IPromise.html) will only be returned when no callback is provided\r\n     * and async is true.\r\n     */\r\n    AppInsightsSku.prototype.flush = function (async, callBack) {\r\n        // @DynamicProtoStub -- DO NOT add any code as this will be removed during packaging\r\n    };\r\n    /**\r\n     * Manually trigger an immediate send of all telemetry still in the buffer using beacon Sender.\r\n     * Fall back to xhr sender if beacon is not supported.\r\n     * @param [async=true]\r\n     * @memberof Initialization\r\n     */\r\n    AppInsightsSku.prototype.onunloadFlush = function (async) {\r\n        if (async === void 0) { async = true; }\r\n        // @DynamicProtoStub -- DO NOT add any code as this will be removed during packaging\r\n    };\r\n    /**\r\n     * Initialize this instance of ApplicationInsights\r\n     * @returns {IApplicationInsights}\r\n     * @memberof Initialization\r\n     * @param legacyMode - MUST always be false, it is no longer supported from v3.x onwards\r\n     */\r\n    AppInsightsSku.prototype.loadAppInsights = function (legacyMode, logger, notificationManager) {\r\n        if (legacyMode === void 0) { legacyMode = false; }\r\n        // @DynamicProtoStub -- DO NOT add any code as this will be removed during packaging\r\n        return null;\r\n    };\r\n    /**\r\n     * Overwrite the lazy loaded fields of global window snippet to contain the\r\n     * actual initialized API methods\r\n     * @param snippet\r\n     * @memberof Initialization\r\n     */\r\n    AppInsightsSku.prototype.updateSnippetDefinitions = function (snippet) {\r\n        // @DynamicProtoStub -- DO NOT add any code as this will be removed during packaging\r\n    };\r\n    /**\r\n     * Call any functions that were queued before the main script was loaded\r\n     * @memberof Initialization\r\n     */\r\n    AppInsightsSku.prototype.emptyQueue = function () {\r\n        // @DynamicProtoStub -- DO NOT add any code as this will be removed during packaging\r\n    };\r\n    AppInsightsSku.prototype.pollInternalLogs = function () {\r\n        // @DynamicProtoStub -- DO NOT add any code as this will be removed during packaging\r\n    };\r\n    AppInsightsSku.prototype.stopPollingInternalLogs = function () {\r\n        // @DynamicProtoStub -- DO NOT add any code as this will be removed during packaging\r\n    };\r\n    AppInsightsSku.prototype.addHousekeepingBeforeUnload = function (appInsightsInstance) {\r\n        // @DynamicProtoStub -- DO NOT add any code as this will be removed during packaging\r\n    };\r\n    AppInsightsSku.prototype.getSender = function () {\r\n        // @DynamicProtoStub -- DO NOT add any code as this will be removed during packaging\r\n        return null;\r\n    };\r\n    /**\r\n     * Unload and Tear down the SDK and any initialized plugins, after calling this the SDK will be considered\r\n     * to be un-initialized and non-operational, re-initializing the SDK should only be attempted if the previous\r\n     * unload call return `true` stating that all plugins reported that they also unloaded, the recommended\r\n     * approach is to create a new instance and initialize that instance.\r\n     * This is due to possible unexpected side effects caused by plugins not supporting unload / teardown, unable\r\n     * to successfully remove any global references or they may just be completing the unload process asynchronously.\r\n     * If you pass isAsync as true and do not provide\r\n     * If you pass isAsync as `true` (also the default) and DO NOT pass a callback function then an [IPromise](https://nevware21.github.io/ts-async/typedoc/interfaces/IPromise.html)\r\n     * will be returned which will resolve once the unload is complete. The actual implementation of the `IPromise`\r\n     * will be a native Promise (if supported) or the default as supplied by [ts-async library](https://github.com/nevware21/ts-async)\r\n     * @param isAsync - Can the unload be performed asynchronously (default)\r\n     * @param unloadComplete - An optional callback that will be called once the unload has completed\r\n     * @param cbTimeout - An optional timeout to wait for any flush operations to complete before proceeding with the\r\n     * unload. Defaults to 5 seconds.\r\n     * @return Nothing or if occurring asynchronously a [IPromise](https://nevware21.github.io/ts-async/typedoc/interfaces/IPromise.html)\r\n     * which will be resolved once the unload is complete, the [IPromise](https://nevware21.github.io/ts-async/typedoc/interfaces/IPromise.html)\r\n     * will only be returned when no callback is provided and isAsync is true\r\n     */\r\n    AppInsightsSku.prototype.unload = function (isAsync, unloadComplete, cbTimeout) {\r\n        // @DynamicProtoStub -- DO NOT add any code as this will be removed during packaging\r\n        return null;\r\n    };\r\n    AppInsightsSku.prototype.getPlugin = function (pluginIdentifier) {\r\n        // @DynamicProtoStub -- DO NOT add any code as this will be removed during packaging\r\n        return null;\r\n    };\r\n    /**\r\n     * Add a new plugin to the installation\r\n     * @param plugin - The new plugin to add\r\n     * @param replaceExisting - should any existing plugin be replaced, default is false\r\n     * @param doAsync - Should the add be performed asynchronously\r\n     * @param addCb - [Optional] callback to call after the plugin has been added\r\n     */\r\n    AppInsightsSku.prototype.addPlugin = function (plugin, replaceExisting, doAsync, addCb) {\r\n        // @DynamicProtoStub -- DO NOT add any code as this will be removed during packaging\r\n    };\r\n    /**\r\n     * Update the configuration used and broadcast the changes to all loaded plugins\r\n     * @param newConfig - The new configuration is apply\r\n     * @param mergeExisting - Should the new configuration merge with the existing or just replace it. Default is to merge.\r\n     */\r\n    AppInsightsSku.prototype.updateCfg = function (newConfig, mergeExisting) {\r\n        // @DynamicProtoStub -- DO NOT add any code as this will be removed during packaging\r\n    };\r\n    /**\r\n     * Returns the unique event namespace that should be used\r\n     */\r\n    AppInsightsSku.prototype.evtNamespace = function () {\r\n        // @DynamicProtoStub -- DO NOT add any code as this will be removed during packaging\r\n        return null;\r\n    };\r\n    /**\r\n     * Add an unload handler that will be called when the SDK is being unloaded\r\n     * @param handler - the handler\r\n     */\r\n    AppInsightsSku.prototype.addUnloadCb = function (handler) {\r\n        // @DynamicProtoStub -- DO NOT add any code as this will be removed during packaging\r\n    };\r\n    /**\r\n     * Add an ajax listener which is called just prior to the request being sent and before the correlation headers are added, to allow you\r\n     * to access the headers and modify the values used to generate the distributed tracing correlation headers. (added in v2.8.4)\r\n     * @param dependencyListener - The Telemetry Initializer function\r\n     * @returns - A IDependencyListenerHandler to enable the initializer to be removed\r\n     */\r\n    AppInsightsSku.prototype.addDependencyListener = function (dependencyListener) {\r\n        // @DynamicProtoStub -- DO NOT add any code as this will be removed during packaging\r\n        return null;\r\n    };\r\n    /**\r\n     * Add an dependency telemetry initializer callback function to allow populating additional properties or drop the request.\r\n     * It is called after the dependency call has completed and any available performance details are available. A dependency\r\n     * initializer is similar to the TelemetryInitializer function but it allows you to block the reporting of the dependency\r\n     * request so that it doesn't count against the `maxAjaxCallsPerView`.\r\n     * @param dependencyInitializer - The Dependency Telemetry Initializer function\r\n     * @returns - A IDependencyInitializerHandler to enable the initializer to be removed\r\n     */\r\n    AppInsightsSku.prototype.addDependencyInitializer = function (dependencyInitializer) {\r\n        return null;\r\n    };\r\n    /**\r\n     * Gets the current distributed trace context for this instance if available\r\n     */\r\n    AppInsightsSku.prototype.getTraceCtx = function () {\r\n        // @DynamicProtoStub -- DO NOT add any code as this will be removed during packaging\r\n        return null;\r\n    };\r\n    /**\r\n     * Watches and tracks changes for accesses to the current config, and if the accessed config changes the\r\n     * handler will be recalled.\r\n     * @param handler\r\n     * @returns A watcher handler instance that can be used to remove itself when being unloaded\r\n     */\r\n    AppInsightsSku.prototype.onCfgChange = function (handler) {\r\n        // @DynamicProtoStub -- DO NOT add any code as this will be removed during packaging\r\n        return null;\r\n    };\r\n    return AppInsightsSku;\r\n}());\r\nexport { AppInsightsSku };\r\n// tslint:disable-next-line\r\nexport function _findSdkSourceFile() {\r\n    if (_internalSdkSrc) {\r\n        // Use the cached value\r\n        return _internalSdkSrc;\r\n    }\r\n    var sdkSrc = null;\r\n    var isModule = false;\r\n    var cdns = [\r\n        \"://js.monitor.azure.com/\",\r\n        \"://az416426.vo.msecnd.net/\"\r\n    ];\r\n    try {\r\n        // Try and determine whether the sdk is being loaded from the CDN\r\n        // currentScript is only valid during initial processing\r\n        var scrpt = (document || {}).currentScript;\r\n        if (scrpt) {\r\n            sdkSrc = scrpt.src;\r\n            // } else {\r\n            //     // We need to update to at least typescript 2.9 for this to work :-(\r\n            //     // Leaving as a stub for now so after we upgrade this breadcrumb is available\r\n            //     let meta = import.meta;\r\n            //     sdkSrc = (meta || {}).url;\r\n            //     isModule = true;\r\n        }\r\n    }\r\n    catch (e) {\r\n        // eslint-disable-next-line no-empty\r\n    }\r\n    if (sdkSrc) {\r\n        try {\r\n            var url_1 = sdkSrc.toLowerCase();\r\n            if (url_1) {\r\n                var src_1 = \"\";\r\n                arrForEach(cdns, function (value, idx) {\r\n                    if (strIndexOf(url_1, value) !== -1) {\r\n                        src_1 = \"cdn\" + (idx + 1);\r\n                        if (strIndexOf(url_1, \"/scripts/\") === -1) {\r\n                            if (strIndexOf(url_1, \"/next/\") !== -1) {\r\n                                src_1 += \"-next\";\r\n                            }\r\n                            else if (strIndexOf(url_1, \"/beta/\") !== -1) {\r\n                                src_1 += \"-beta\";\r\n                            }\r\n                        }\r\n                        _internalSdkSrc = src_1 + (isModule ? \".mod\" : \"\");\r\n                        return -1;\r\n                    }\r\n                });\r\n            }\r\n        }\r\n        catch (e) {\r\n            // eslint-disable-next-line no-empty\r\n        }\r\n        // Cache the found value so we don't have to look it up again\r\n        _internalSdkSrc = sdkSrc;\r\n    }\r\n    return _internalSdkSrc;\r\n}\r\n//# sourceMappingURL=AISku.js.map","// Copyright (c) Microsoft Corporation. All rights reserved.\r\n// Licensed under the MIT License.\r\n// ###################################################################################################################################################\r\n// Note: DON'T Export these const from the package as we are still targeting IE/ES5 this will export a mutable variables that someone could change ###\r\n// ###################################################################################################################################################\r\n// Generally you should only put values that are used more than 2 times and then only if not already exposed as a constant (such as SdkCoreNames)\r\n// as when using \"short\" named values from here they will be will be minified smaller than the SdkCoreNames[eSdkCoreNames.xxxx] value.\r\nvar _AUTHENTICATED_USER_CONTEXT = \"AuthenticatedUserContext\";\r\nvar _TRACK = \"track\";\r\nexport var STR_EMPTY = \"\";\r\nexport var STR_SNIPPET = \"snippet\";\r\nexport var STR_GET_COOKIE_MGR = \"getCookieMgr\";\r\nexport var STR_START_TRACK_PAGE = \"startTrackPage\";\r\nexport var STR_STOP_TRACK_PAGE = \"stopTrackPage\";\r\nexport var STR_FLUSH = \"flush\";\r\nexport var STR_START_TRACK_EVENT = \"startTrackEvent\";\r\nexport var STR_STOP_TRACK_EVENT = \"stopTrackEvent\";\r\nexport var STR_ADD_TELEMETRY_INITIALIZER = \"addTelemetryInitializer\";\r\nexport var STR_ADD_TELEMETRY_INITIALIZERS = STR_ADD_TELEMETRY_INITIALIZER + \"s\";\r\nexport var STR_POLL_INTERNAL_LOGS = \"pollInternalLogs\";\r\nexport var STR_GET_PLUGIN = \"getPlugin\";\r\nexport var STR_EVT_NAMESPACE = \"evtNamespace\";\r\nexport var STR_TRACK_EVENT = _TRACK + \"Event\";\r\nexport var STR_TRACK_TRACE = _TRACK + \"Trace\";\r\nexport var STR_TRACK_METRIC = _TRACK + \"Metric\";\r\nexport var STR_TRACK_PAGE_VIEW = _TRACK + \"PageView\";\r\nexport var STR_TRACK_EXCEPTION = _TRACK + \"Exception\";\r\nexport var STR_TRACK_DEPENDENCY_DATA = _TRACK + \"DependencyData\";\r\nexport var STR_SET_AUTHENTICATED_USER_CONTEXT = \"set\" + _AUTHENTICATED_USER_CONTEXT;\r\nexport var STR_CLEAR_AUTHENTICATED_USER_CONTEXT = \"clear\" + _AUTHENTICATED_USER_CONTEXT;\r\n//# sourceMappingURL=InternalConstants.js.map","// Copyright (c) Microsoft Corporation. All rights reserved.\r\n// Licensed under the MIT License.\r\n// @skip-file-minify\r\n// ##############################################################\r\n// AUTO GENERATED FILE: This file is Auto Generated during build.\r\n// ##############################################################\r\n// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\r\n// Note: DON'T Export these const from the package as we are still targeting ES3 this will export a mutable variables that someone could change!!!\r\n// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\r\nexport var _DYN_VERSION = \"version\"; // Count: 6\r\nexport var _DYN_QUEUE = \"queue\"; // Count: 6\r\nexport var _DYN_CONNECTION_STRING = \"connectionString\"; // Count: 4\r\nexport var _DYN_ENDPOINT_URL = \"endpointUrl\"; // Count: 3\r\nexport var _DYN_INSTRUMENTATION_KEY = \"instrumentationKey\"; // Count: 3\r\nexport var _DYN_DISABLE_IKEY_DEPRECA0 = \"disableIkeyDeprecationMessage\"; // Count: 2\r\nexport var _DYN_ONUNLOAD_FLUSH = \"onunloadFlush\"; // Count: 6\r\nexport var _DYN_CONTEXT = \"context\"; // Count: 5\r\nexport var _DYN_ADD_HOUSEKEEPING_BEF1 = \"addHousekeepingBeforeUnload\"; // Count: 2\r\nexport var _DYN_UPDATE_SNIPPET_DEFIN2 = \"updateSnippetDefinitions\"; // Count: 2\r\n//# sourceMappingURL=__DynamicConstants.js.map","// Copyright (c) Microsoft Corporation. All rights reserved.\r\n// Licensed under the\r\nexport { correlationIdSetPrefix, correlationIdGetPrefix, correlationIdCanIncludeCorrelationHeader, correlationIdGetCorrelationContext, correlationIdGetCorrelationContextValue, dateTimeUtilsNow, dateTimeUtilsDuration, isInternalApplicationInsightsEndpoint, createDistributedTraceContextFromTrace } from \"./Util\";\r\nexport { ThrottleMgr } from \"./ThrottleMgr\";\r\nexport { parseConnectionString, ConnectionStringParser } from \"./ConnectionStringParser\";\r\nexport { RequestHeaders } from \"./RequestResponseHeaders\";\r\nexport { DisabledPropertyName, ProcessLegacy, SampleRate, HttpMethod, DEFAULT_BREEZE_ENDPOINT, DEFAULT_BREEZE_PATH, strNotSpecified } from \"./Constants\";\r\nexport { Envelope } from \"./Telemetry/Common/Envelope\";\r\nexport { Event } from \"./Telemetry/Event\";\r\nexport { Exception } from \"./Telemetry/Exception\";\r\nexport { Metric } from \"./Telemetry/Metric\";\r\nexport { PageView } from \"./Telemetry/PageView\";\r\nexport { RemoteDependencyData } from \"./Telemetry/RemoteDependencyData\";\r\nexport { Trace } from \"./Telemetry/Trace\";\r\nexport { PageViewPerformance } from \"./Telemetry/PageViewPerformance\";\r\nexport { Data } from \"./Telemetry/Common/Data\";\r\nexport { SeverityLevel } from \"./Interfaces/Contracts/SeverityLevel\";\r\nexport { ConfigurationManager } from \"./Interfaces/IConfig\";\r\nexport { ContextTagKeys } from \"./Interfaces/Contracts/ContextTagKeys\";\r\nexport { dataSanitizeKeyAndAddUniqueness, dataSanitizeKey, dataSanitizeString, dataSanitizeUrl, dataSanitizeMessage, dataSanitizeException, dataSanitizeProperties, dataSanitizeMeasurements, dataSanitizeId, dataSanitizeInput, dsPadNumber } from \"./Telemetry/Common/DataSanitizer\";\r\nexport { TelemetryItemCreator, createTelemetryItem } from \"./TelemetryItemCreator\";\r\nexport { CtxTagKeys, Extensions } from \"./Interfaces/PartAExtensions\";\r\nexport { DistributedTracingModes } from \"./Enums\";\r\nexport { stringToBoolOrDefault, msToTimeSpan, getExtensionByName, isCrossOriginError } from \"./HelperFuncs\";\r\nexport { isBeaconsSupported as isBeaconApiSupported, createTraceParent, parseTraceParent, isValidTraceId, isValidSpanId, isValidTraceParent, isSampledFlag, formatTraceParent, findW3cTraceParent } from \"@microsoft/applicationinsights-core-js\";\r\nexport { createDomEvent } from \"./DomHelperFuncs\";\r\nexport { utlDisableStorage, utlEnableStorage, utlCanUseLocalStorage, utlGetLocalStorage, utlSetLocalStorage, utlRemoveStorage, utlCanUseSessionStorage, utlGetSessionStorageKeys, utlGetSessionStorage, utlSetSessionStorage, utlRemoveSessionStorage } from \"./StorageHelperFuncs\";\r\nexport { urlParseUrl, urlGetAbsoluteUrl, urlGetPathName, urlGetCompleteUrl, urlParseHost, urlParseFullHost } from \"./UrlHelperFuncs\";\r\nexport var PropertiesPluginIdentifier = \"AppInsightsPropertiesPlugin\";\r\nexport var BreezeChannelIdentifier = \"AppInsightsChannelPlugin\";\r\nexport var AnalyticsPluginIdentifier = \"ApplicationInsightsAnalytics\";\r\n//# sourceMappingURL=applicationinsights-common.js.map"],"names":["SeverityLevel","createEnumStyle","createEnum","Verbose","Information","Warning","Error","Critical","Constructor","Prototype","strFunction","DynInstFuncTable","DynProxyTag","DynClassName","DynInstChkTag","DynAllowInstChkTag","DynProtoDefaultOptions","UnknownValue","str__Proto","DynProtoBaseProto","DynProtoGlobalSettings","DynProtoCurrent","strUseBaseInst","strSetInstFuncs","Obj","Object","_objGetPrototypeOf","_objGetOwnProps","_gbl","getGlobal","_gblInst","o","_a","n","_isObjectOrArrayPrototype","target","Array","_isObjectArrayOrFunctionPrototype","Function","_getObjProto","newProto","curProto","objHasOwnProperty","_forEachProp","func","props","name_1","push","length","lp","_isDynamicCandidate","funcName","skipOwn","_throwTypeError","message","throwTypeError","_hasVisited","values","value","_populatePrototype","proto","className","baseInstFuncs","setInstanceFunc","_createDynamicPrototype","dynProtoProxy","instFunc","currentDynProtoProxy","instFuncTable","objCreate","canAddInst","objProto","visited","protoFunc","e","_getInstFunc","this","_getProtoFunc","apply","arguments","instFuncs_1","name","_getObjName","unknownValue","dynamicProto","theClass","delegateFunc","options","classProto","thisTarget","thisProto","_checkPrototype","perfOptions","useBaseInst","undefined","instFuncs","_getInstanceFuncs","baseFuncs","_instFuncProxy","funcHost","theFunc","baseProto","_getBaseFuncs","_DYN_SPLIT","_DYN_LENGTH","_DYN_INGESTIONENDPOINT","parseConnectionString","connectionString","kvPairs","result","arrReduce","fields","kv","kvParts","key","objKeys","endpointsuffix","locationPrefix","location","_DYN_BLK_VAL","_DYN_RD_ONLY","_DYN_NOTIFY","_DYN_WARN_TO_CONSOLE","_DYN_THROW_INTERNAL","_DYN_SET_DF","_DYN_WATCH","_DYN_LOGGER","_DYN_APPLY","_DYN_PUSH","_DYN_SPLICE","_DYN_HDLR","_DYN_CANCEL","_DYN_INITIALIZE","_DYN_IDENTIFIER","_DYN_IS_INITIALIZED","_DYN_GET_PLUGIN","_DYN_POLL_INTERNAL_LOGS","_DYN_NAME","_DYN_TIME","_DYN_PROCESS_NEXT","_DYN_GET_PROCESS_TEL_CONT0","_DYN_GET_NOTIFY_MGR","_DYN_ADD_NOTIFICATION_LIS1","_DYN_REMOVE_NOTIFICATION_2","_DYN_ENABLED","_DYN_STOP_POLLING_INTERNA3","_DYN_UNLOAD","_DYN_ON_COMPLETE","_DYN_VERSION","_DYN_LOGGING_LEVEL_CONSOL4","_DYN_CREATE_NEW","_DYN_TEARDOWN","_DYN_MESSAGE_ID","_DYN_MESSAGE","_DYN_IS_ASYNC","_DYN_DIAG_LOG","_DYN__DO_TEARDOWN","_DYN_UPDATE","_DYN_GET_NEXT","_DYN_SET_NEXT_PLUGIN","_DYN_USER_AGENT","_DYN_NODE_TYPE","_DYN_REPLACE","_DYN_TYPE","_DYN_HANDLER","_DYN_IS_CHILD_EVT","_DYN_GET_CTX","_DYN_SET_CTX","_DYN_COMPLETE","_DYN_TRACE_ID","_DYN_SPAN_ID","_DYN_TRACE_FLAGS","UNDEFINED_VALUE","STR_EMPTY","STR_CHANNELS","STR_CORE","STR_CREATE_PERF_MGR","STR_DISABLED","STR_EXTENSION_CONFIG","STR_EXTENSIONS","STR_PROCESS_TELEMETRY","STR_PRIORITY","STR_EVENTS_SENT","STR_EVENTS_DISCARDED","STR_EVENTS_SEND_REQUEST","STR_PERF_EVENT","STR_GET_PERF_MGR","STR_DOMAIN","STR_PATH","rCamelCase","rNormalizeInvalid","rLeadingNumeric","isNotNullOrUndefined","isNullOrUndefined","normalizeJsName","isString","_all","letter","toUpperCase","match","strContains","search","strIndexOf","toISOString","date","getExceptionName","object","isError","setValue","field","valChk","srcChk","theValue","_createProxyFunction","source","srcFunc","src","isFunction","originalArguments","proxyFunctionAs","overwriteTarget","isUndefined","proxyFunctions","functionsToProxy","isObject","isArray","arrForEach","theFuncName","strShimObject","strShimPrototype","ObjClass","strJSON","strMsie","strTrident","_isTrident","_navUserAgentCheck","_enableMocks","hasJSON","Boolean","JSON","getInst","isIE","nav","getNavigator","userAgent","UInt32Mask","MaxUInt32","SEED1","SEED2","_mwcSeeded","_mwcW","_mwcZ","_mwcSeed","seedValue","_autoSeedMwc","now","utcNow","Math","random","random32","signed","c","getRandomValues","Uint32Array","mwcRandom32","floor","version","instanceName","maxLength","number","chars","charAt","newId","_dataUid","_canAcceptData","createUniqueNamespace","includeVersion","createElmNodeData","data","id","accept","get","defValue","addDefault","theCache","objDefine","v","_getCache","kill","_isConfigDefaults","isVal","fb","objHasOwn","set","_getDefault","dynamicHandler","theConfig","cfgDefaults","isDefaultValid","dfVal","isDefined","fallbacks","fallback","fbValue","cfg","asString","_resolveDefaultValue","newValue_1","isPlainObject","objForEachKey","_applyDefaultValue","defaultValue","isValid","setFn","mergeDf","reference","readOnly","blkDynamicValue","mrg","ref","usingDefault","cfgValue","dfName","dfValue","CFG_HANDLER_LINK","symbolFor","BLOCK_DYNAMIC","FORCE_DYNAMIC","_cfgDeepCopy","target_1","_canMakeDynamic","getFunc","state","blkVal","throwInvalidAccess","aggregationErrorType","arrayMethodsToPatch","_throwDynamicError","logger","desc","concat","dumpObj","_getOwnPropGetter","propDesc","objGetOwnPropertyDescriptor","_setDynamicProperty","getter","prop","detail","h","trk","handler","fn","arrIndexOf","clr","idx","checkDynamic","isObjectOrArray","_getProperty","_makeDynamicObject","activeHandler","act","chng","add","g","s","newValue","ro","upd","isReferenced","rf","hdlr","valueState","newIsObjectOrArray","_createDynamicProperty","_setDynamicPropertyState","flags","isDynamic","inPlace","rdOnly","blkProp","blockDynamicConversion","objDefineProp","method","orgMethod","args","_i","_patchArray","symPrefix","symPostfix","_createState","cfgHandler","theState","dynamicPropertySymbol","newSymbol","uid","dynamicPropertyReadOnly","dynamicPropertyReferenced","dynamicPropertyBlockValue","dynamicPropertyDetail","_waitingHandlers","_watcherTimer","_useHandler","callback","prevWatcher","bind","setDf","_notifyWatchers","notifyHandlers","watcherFailures_1","sourceErrors","createCustomError","self","errors","theMessage","srcError","throwAggregationError","scheduleTimeout","use","details","_createDynamicHandler","getDynamicConfigHandler","newTarget","defaultValues","configHandler","rm","_createAndUseHandler","_block","allowUpdate","prevUpd","w","createDynamicConfig","config","defaultConfig","onConfigChange","_logInvalidAccess","strHasOwnProperty","extendStaticsFn","d","b","__proto__","p","__spreadArrayFn","to","from","i","il","j","runTargetUnload","isAsync","doUnloadAll","targets","done","createPromise","resolved","getLength","doAwaitResponse","arrSlice","_debugListener","listenerFuncs","_aiNamespace","_listenerProxyFunc","dbgExt","getDebugExt","listener","ns","disableDbgExt","_getExtensionNamespace","getDebugListener","STR_WARN_TO_CONSOLE","loggingLevelConsole","loggingLevelTelemetry","maxMessageLimit","enableDebug","_logFuncs","_sanitizeDiagnosticText","text","_logToConsole","theConsole","console","logFunc","_InternalLogMessage","msgId","msg","isUserAct","properties","_self","strProps","stringify","diagnosticText","dataType","safeGetLogger","core","DiagnosticLogger","_b","identifier","queue","_loggingLevelConsole","_loggingLevelTelemetry","_maxInternalMessageLimit","_enableDebug","_unloadHandler","_messageCount","_messageLogged","_logInternalMessage","severity","logMessage","messageKey","_debugExtMsg","throttleLimitMessage","throttleMessage","errorToConsole","_setDefaultsFromConfig","consoleLoggingLevel","debugToConsole","resetInternalMessageCount","_getLogger","_throwInternal","_doc","strToGMTString","strToUTCString","strCookie","strExpires","strIsCookieUseDisabled","strDisableCookiesUsage","strConfigCookieMgr","_supportsCookies","_allowUaSameSite","_parsedCookieValue","_cookieCache","_globalCookieConfig","rootDefaultConfig","cookieCfg","path","enabled","ignoreCookies","blockedCookies","cookieDomain","cookiePath","_getDoc","getLazy","getDocument","_isMgrEnabled","cookieMgr","isEnabled","_isIgnoredCookie","cookieMgrCfg","_isCfgEnabled","rootConfig","cookieMgrConfig","isCfgEnabled","cookieEnabled","createCookieMgr","_path","_domain","unloadHandler","_enabled","_getCookieFn","_setCookieFn","_delCookieFn","getCookie","_getCookieValue","setCookie","_setCookieValue","delCookie","areCookiesSupported","gblManager","setEnabled","maxAgeSec","domain","_isBlockedCookie","strTrim","strLeft","_extractParts","strSubstring","isTruthy","_isIE","expireMs","expiry","Date","setTime","_formatDate","location_1","checkForMock","mockLocation","getLocation","protocol","strEndsWith","uaDisallowsSameSiteNone","_formatCookieValue","del","purge","doc","exception","parts","thePart","theDate","cookieValue","theCookie","perfEvtsSendAll","_runListeners","listeners","NotificationManager","_listeners","index","events","reason","sendReason","perfEvent","waiting","_finishUnload","asyncUnload","resolve","createAllPromise","strExecutionContextKey","strParentContextKey","strChildrenContextKey","_defaultPerfManager","PerfEvent","payloadDetails","theDetails_1","start","childTime","childEvts","childEvt","exTime","ParentContextKey","ChildrenContextKey","PerfManager","manager","ctx","create","fire","doPerfActiveKey","doPerf","mgrSource","getSource","perfMgr","perfEvt","currentActive","children","ex","INVALID_TRACE_ID","INVALID_SPAN_ID","_isValid","len","invalidValue","isValidTraceId","isValidSpanId","pluginStateData","_getPluginState","plugin","initializePlugins","processContext","extensions","pluginState","initPlugins","lastPlugin","proxy","thePlugin","isInitialized","getCfg","sortPlugins","plugins","sort","extA","extB","bHasProcess","strTelemetryPluginChain","strHasRunFlags","strGetTelCtx","_chainId","_createInternalContext","telemetryChain","startAt","_nextProxy","_onComplete","createTelemetryProxyChain","_getNextProxyStart","context","_next","nextProxy","onComplete","completeDetails","call","diagLog","getExtCfg","newConfig","_getExtCfg","getConfig","extConfig","hasNext","getNext","setNext","nextPlugin","iterate","cb","that","createIfMissing","idCfg","extCfg","createProcessTelemetryContext","internalContext","env","createProcessTelemetryUnloadContext","unloadState","createProcessTelemetryUpdateContext","updateState","firstProxy","lastProxy_1","newProxy","chainId","hasProcessTelemetry","hasSetNext","proxyChain","getPlugin","processTelemetry","_processTelemetry","unload","_unloadPlugin","update","_updatePlugin","_id","_setNext","_getTelCtx","itemCtx","_processChain","processPluginFn","hasRun","hasRunContext","nextId","error","hasNextRun","_callProcessTelemetry","item","sync","unloadCtx","_callTeardown","pluginCore","updateCtx","_callUpdate","objFreeze","createTelemetryPluginProxy","createUnloadHandlerContainer","handlers","run","createUnloadHookContainer","_hooks","oldHooks","remove","hooks","arrAppend","strGetPlugin","BaseTelemetryPlugin","_isinitialized","_rootCtx","_nextPlugin","_unloadHandlerContainer","_hookContainer","currentCtx","rootCtx","_setDefaults","pluginChain","_initDefaults","unloadDone","theUnloadCtx","theUnloadState","_unloadCallback","updateDone","theUpdateCtx","theUpdateState","_doUpdate","_updateCallback","setInitialized","next","TelemetryInitializerPlugin","_super","_initializers","_this","priority","_base","addTelemetryInitializer","telemetryInitializer","theInitializer","initializer","_addInitializer","doNotSendItem","telemetryInitializersCount","_runInitializers","__","constructor","String","__extends","strValidationError","strSdkUnloadingError","objDeepFreeze","diagnosticLogInterval","_createPerfManager","notificationMgr","_validateExtensions","channelPriority","allExtensions","coreExtensions","channels","extPriorities","ext","throwError","extPriority","_warnToConsole","_isPluginPresent","exists","_deepMergeConfig","newValues","merge","_findWatcher","newWatcher","theListener","l","AppInsightsCore","_configHandler","_isInitialized","_logger","_eventQueue","_notificationManager","_perfManager","_cfgPerfManager","_cookieManager","_pluginChain","_configExtensions","_channelConfig","_channels","_isUnloading","_telemetryInitializerPlugin","_internalLogsEventName","_evtNamespace","_unloadHandlers","_traceCtx","_instrumentationKey","_cfgListeners","_extensions","_pluginVersionStringArr","_pluginVersionString","_internalLogPoller","_internalLogPollerListening","_forceStopInternalLogPoller","_startLogPoller","alwaysStart","_addUnloadHook","interval","isRunning","createTimeout","_flushInternalLogs","unref","_setPluginVersions","thePlugins","_addPluginVersions","ver","updateCfg","join","newLogger","cfgExtensions","splice","_createTelCtx","theCtx","_getPluginChain","_initPluginChain","theExtensions","_getPlugin","pluginIdentifier","theExt","channelHosts","getChannel","host","removeCb","pluginsToRemove","_removePlugins","removed","slice","removeComplete","newConfigExtensions","newChannelConfig","newQueue","channel","iKey","baseType","baseData","track","_flushChannels","callBack","cbTimeout","doneIterating","cbTimer","doCallback","flush","handled_1","_updateHook","_logOrThrowError","_notifyInvalidEvent","telemetryItem","notificationManager","instrumentationKey","enablePerfMgr","getSetValue","__spreadArray","teeController","unloadHdl","_registerDelayedCfgListener","releaseQueue","getChannels","controls","getCookieMgr","setCookieMgr","createPerfMgr","setPerfMgr","eventCnt","eventQueue","event","eventName","unloadComplete","flushComplete","processUnloadCtx","_doUnload","addPlugin","replaceExisting","addCb","existingPlugin","_addPlugin","added","removedPlugins_1","mergeExisting","oldCfg","deepExtend","evtNamespace","getTraceCtx","createNew","parentCtx","trace","getName","setName","getTraceId","setTraceId","getSpanId","setSpanId","getTraceFlags","setTraceFlags","newTraceFlags","createDistributedTraceContext","setTraceCtx","traceCtx","addUnloadHook","onCfgChange","unloadHook","fnd","_addDelayedCfgListener","getWParam","hasDocument","enableWParam","strAttachEvent","strAddEventHelper","strDetachEvent","strRemoveEventListener","strEvents","strVisibilityChangeEvt","strPageHide","strUnload","strBeforeUnload","strPageHideNamespace","rRemoveEmptyNs","rRemoveTrailingEmptyNs","_guid","elmNodeData","eventNamespace","_normalizeNamespace","_getEvtNamespace","theNamespace_1","parsedEvent","exec","replace","_getRegisteredEvents","evtName","aiEvts","registeredEvents","_doDetach","obj","handlerRef","useCapture","_doUnregister","unRegFn","theEvent","capture","mergeEvtNamespace","theNamespace","namespaces","eventOn","_doAttach","registeredEvent","guid","type","eventOff","evtName_1","found_1","eventCache","evtType","_unregisterEvents","regEvent","_addEventListeners","excludeEvents","getWindow","addEventHandler","removeEventListeners","removeEventHandler","addPageUnloadEventListener","addEventListeners","addPageHideEventListener","newNamespaces","pageUnloadAdded","evt","visibilityState","_internalSdkSrc","_AUTHENTICATED_USER_CONTEXT","_TRACK","STR_SNIPPET","STR_FLUSH","STR_ADD_TELEMETRY_INITIALIZER","STR_POLL_INTERNAL_LOGS","STR_GET_PLUGIN","STR_EVT_NAMESPACE","STR_TRACK_EVENT","STR_TRACK_TRACE","STR_TRACK_METRIC","STR_TRACK_PAGE_VIEW","STR_TRACK_EXCEPTION","STR_TRACK_DEPENDENCY_DATA","STR_SET_AUTHENTICATED_USER_CONTEXT","STR_CLEAR_AUTHENTICATED_USER_CONTEXT","_DYN_QUEUE","_DYN_CONNECTION_STRING","_DYN_ENDPOINT_URL","_DYN_INSTRUMENTATION_KEY","_DYN_DISABLE_IKEY_DEPRECA0","_DYN_ONUNLOAD_FLUSH","_DYN_CONTEXT","_DYN_ADD_HOUSEKEEPING_BEF1","_ignoreUpdateSnippetProperties","defaultConfigValues","validator","fallBackName","cfgDfValidate","AppInsightsSku","snippet","dependencies","_sender","_snippetVersion","_houseKeepingNamespace","_core","_config","_analyticsPlugin","sv","AnalyticsPlugin","PropertiesPlugin","DependenciesPlugin","Sender","cs","ingest","ingestionendpoint","instrumentationkey","isErrMessageDisabled","_removePageEventHandlers","removePageHideEventListener","async","flushDone","loadAppInsights","legacyMode","throwUnsupported","initialize","sdkSrc","isModule","cdns","scrpt","document","currentScript","url_1","toLowerCase","src_1","_findSdkSourceFile","internal","snippetVer","_updateSnippetProperties","emptyQueue","chkSet","_loop_1","proxyAssign","length_1","toString","appInsightsInstance","hasWindow","performHousekeeping_1","loadedPlugin","propertiesPlugin","_sessionManager","backup","added_1","analyticsPlugin_1","appInsights","theConfig_1","excludePageUnloadEvents","disablePageUnloadEvents","disableFlushOnBeforeUnload","product","isReactNative","disableFlushOnUnload","getSender","user","prototype","addDependencyInitializer","dependencyInitializer"],"sourceRoot":""}