{"version":3,"file":"static/js/6577_89fcaaeb6584b72a0644.js","mappings":"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","sources":["file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@microsoft+applicationinsights-core-js@3.0.7_tslib@2.8.1/node_modules/@microsoft/applicationinsights-core-js/dist-es5/Config/ConfigDefaultHelpers.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@microsoft+applicationinsights-core-js@3.0.7_tslib@2.8.1/node_modules/@microsoft/applicationinsights-core-js/dist-es5/Config/ConfigDefaults.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@microsoft+applicationinsights-core-js@3.0.7_tslib@2.8.1/node_modules/@microsoft/applicationinsights-core-js/dist-es5/Config/DynamicSupport.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@microsoft+applicationinsights-core-js@3.0.7_tslib@2.8.1/node_modules/@microsoft/applicationinsights-core-js/dist-es5/Config/DynamicProperty.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@microsoft+applicationinsights-core-js@3.0.7_tslib@2.8.1/node_modules/@microsoft/applicationinsights-core-js/dist-es5/Config/DynamicState.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@microsoft+applicationinsights-core-js@3.0.7_tslib@2.8.1/node_modules/@microsoft/applicationinsights-core-js/dist-es5/Config/DynamicConfig.js"],"sourcesContent":["/*\n * Application Insights JavaScript SDK - Core, 3.0.7\n * Copyright (c) Microsoft and contributors. All rights reserved.\n */\n\r\n\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","/*\n * Application Insights JavaScript SDK - Core, 3.0.7\n * Copyright (c) Microsoft and contributors. All rights reserved.\n */\n\r\n\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","/*\n * Application Insights JavaScript SDK - Core, 3.0.7\n * Copyright (c) Microsoft and contributors. All rights reserved.\n */\n\r\n\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","/*\n * Application Insights JavaScript SDK - Core, 3.0.7\n * Copyright (c) Microsoft and contributors. All rights reserved.\n */\n\r\n\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","/*\n * Application Insights JavaScript SDK - Core, 3.0.7\n * Copyright (c) Microsoft and contributors. All rights reserved.\n */\n\r\n\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","/*\n * Application Insights JavaScript SDK - Core, 3.0.7\n * Copyright (c) Microsoft and contributors. All rights reserved.\n */\n\r\n\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"],"names":["_stringToBoolOrDefault","theValue","defaultValue","theConfig","cfgDfMerge","mrg","v","cfgDfSet","setter","set","cfgDfValidate","validator","fallBackName","fb","isVal","cfgDfBoolean","cfgDfString","_isConfigDefaults","value","_getDefault","dynamicHandler","cfgDefaults","defValue","isDefaultValid","dfVal","fallbacks","lp","fallback","fbValue","cfg","_resolveDefaultValue","newValue_1","key","_applyDefaultValue","name","isValid","setFn","mergeDf","reference","readOnly","blkDynamicValue","ref","usingDefault","cfgValue","dfName","dfValue","CFG_HANDLER_LINK","symbol","BLOCK_DYNAMIC","FORCE_DYNAMIC","_cfgDeepCopy","source","target_1","_canMakeDynamic","getFunc","state","result","blkVal","throwInvalidAccess","message","arrayMethodsToPatch","_throwDynamicError","logger","desc","e","concat","_getOwnPropGetter","target","propDesc","get","_setDynamicProperty","getter","prop","detail","n","h","trk","handler","fn","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","method","orgMethod","args","_i","arguments","length","this","_patchArray","symPrefix","symPostfix","_createDynamicHandler","_a","getDynamicConfigHandler","theState","uid","newTarget","cfgHandler","defaultValues","configHandler","rm","use","_createAndUseHandler","_block","allowUpdate","details","prevUpd","c","w","dynamicPropertySymbol","dynamicPropertyReadOnly","dynamicPropertyReferenced","dynamicPropertyBlockValue","dynamicPropertyDetail","_waitingHandlers","_watcherTimer","_useHandler","callback","prevWatcher","bind","setDf","_notifyWatchers","notifyHandlers","watcherFailures_1","_createState","createDynamicConfig","config","defaultConfig","onConfigChange","_logInvalidAccess"],"sourceRoot":""}