@microsoft/applicationinsights-analytics-js 3.3.5-nightly3.2501-07 → 3.3.5-nightly3.2502-02

package/dist/es5/applicationinsights-analytics-js.js

@@ -1,5 +1,5 @@
 /*!
- * Application Insights JavaScript SDK - Web Analytics, 3.3.5-nightly3.2501-07
+ * Application Insights JavaScript SDK - Web Analytics, 3.3.5-nightly3.2502-02
  * Copyright (c) Microsoft and contributors. All rights reserved.
  */
 (function (global, factory) {
@@ -1345,7 +1345,7 @@
         return result;
     }
 
-    var version = '3.3.5-nightly3.2501-07';
+    var version = '3.3.5-nightly3.2502-02';
     var instanceName = "." + newId(6);
     var _dataUid = 0;
     function _canAcceptData(target) {
@@ -3610,6 +3610,7 @@
     var _DYN_COUNT = "count";
     var _DYN_STRINGIFY = "stringify";
     var _DYN_PATHNAME = "pathname";
+    var _DYN_MATCH = "match";
     var _DYN_EXCEPTIONS = "exceptions";
     var _DYN_PARSED_STACK = "parsedStack";
     var _DYN_PROPERTIES$1 = "properties";
@@ -3619,13 +3620,13 @@
     var _DYN_SEVERITY_LEVEL = "severityLevel";
     var _DYN_PROBLEM_GROUP = "problemGroup";
     var _DYN_IS_MANUAL = "isManual";
-    var _DYN__CREATE_FROM_INTERFA1 = "CreateFromInterface";
+    var _DYN_HAS_FULL_STACK = "hasFullStack";
     var _DYN_ASSEMBLY = "assembly";
     var _DYN_FILE_NAME = "fileName";
-    var _DYN_HAS_FULL_STACK = "hasFullStack";
-    var _DYN_LEVEL = "level";
-    var _DYN_METHOD = "method";
     var _DYN_LINE = "line";
+    var _DYN_METHOD = "method";
+    var _DYN_LEVEL = "level";
+    var _DYN_AI_DATA_CONTRACT = "aiDataContract";
     var _DYN_DURATION$1 = "duration";
     var _DYN_RECEIVED_RESPONSE = "receivedResponse";
 
@@ -3765,7 +3766,7 @@
     function urlParseHost(url, inclPort) {
         var fullHost = urlParseFullHost(url, inclPort) || "";
         if (fullHost) {
-            var match = fullHost.match(/(www\d{0,5}\.)?([^\/:]{1,256})(:\d{1,20})?/i);
+            var match = fullHost[_DYN_MATCH ](/(www\d{0,5}\.)?([^\/:]{1,256})(:\d{1,20})?/i);
             if (match != null && match[_DYN_LENGTH$1 ] > 3 && isString(match[2]) && match[2][_DYN_LENGTH$1 ] > 0) {
                 return match[2] + (match[3] || "");
             }
@@ -3775,7 +3776,7 @@
     function urlParseFullHost(url, inclPort) {
         var result = null;
         if (url) {
-            var match = url.match(/(\w{1,150}):\/\/([^\/:]{1,256})(:\d{1,20})?/i);
+            var match = url[_DYN_MATCH ](/(\w{1,150}):\/\/([^\/:]{1,256})(:\d{1,20})?/i);
             if (match != null && match[_DYN_LENGTH$1 ] > 2 && isString(match[2]) && match[2][_DYN_LENGTH$1 ] > 0) {
                 result = match[2] || "";
                 if (inclPort && match[_DYN_LENGTH$1 ] > 2) {
@@ -3985,6 +3986,14 @@
         return Event;
     }());
 
+    var STACKFRAME_BASE_SIZE = 58;
+    var IS_FRAME = /^\s{0,50}(from\s|at\s|Line\s{1,5}\d{1,10}\s{1,5}of|\w{1,50}@\w{1,80}|[^\(\s\n]+:[0-9\?]+(?::[0-9\?]+)?)/;
+    var FULL_STACK_FRAME_1 = /^(?:\s{0,50}at)?\s{0,50}([^\@\()\s]+)?\s{0,50}(?:\s|\@|\()\s{0,5}([^\(\s\n\]]+):([0-9\?]+):([0-9\?]+)\)?$/;
+    var FULL_STACK_FRAME_2 = /^(?:\s{0,50}at)?\s{0,50}([^\@\()\s]+)?\s{0,50}(?:\s|\@|\()\s{0,5}([^\(\s\n\]]+):([0-9\?]+)\)?$/;
+    var FULL_STACK_FRAME_3 = /^(?:\s{0,50}at)?\s{0,50}([^\@\()\s]+)?\s{0,50}(?:\s|\@|\()\s{0,5}([^\(\s\n\)\]]+)\)?$/;
+    var EXTRACT_FILENAME = /(?:^|\(|\s{0,10}[\w\)]+\@)?([^\(\n\s\]\)]+)(?:\:([0-9]+)(?:\:([0-9]+))?)?\)?(?:,|$)/;
+    var PARSE_FILENAME_LINE_COL = /([^\(\s\n]+):([0-9]+):([0-9]+)$/;
+    var PARSE_FILENAME_LINE_ONLY = /([^\(\s\n]+):([0-9]+)$/;
     var NoMethod = "<no_method>";
     var strError = "error";
     var strStack = "stack";
@@ -3992,6 +4001,18 @@
     var strErrorSrc = "errorSrc";
     var strMessage = "message";
     var strDescription = "description";
+    var _parseSequence = [
+        { re: FULL_STACK_FRAME_1, len: 5, m: 1, fn: 2, ln: 3, col: 4 },
+        { chk: _ignoreNative, pre: _scrubAnonymous, re: FULL_STACK_FRAME_2, len: 4, m: 1, fn: 2, ln: 3 },
+        { re: FULL_STACK_FRAME_3, len: 3, m: 1, fn: 2, hdl: _handleFilename },
+        { re: EXTRACT_FILENAME, len: 2, fn: 1, hdl: _handleFilename }
+    ];
+    function _scrubAnonymous(frame) {
+        return frame.replace(/(\(anonymous\))/, "<anonymous>");
+    }
+    function _ignoreNative(frame) {
+        return strIndexOf(frame, "[native") < 0;
+    }
     function _stringify(value, convertToString) {
         var result = value;
         if (result && !isString(result)) {
@@ -4139,9 +4160,7 @@
         var stack = "";
         if (stackDetails) {
             if (stackDetails.obj) {
-                arrForEach(stackDetails.obj, function (entry) {
-                    stack += entry + "\n";
-                });
+                stack = stackDetails.obj.join("\n");
             }
             else {
                 stack = stackDetails.src || "";
@@ -4155,13 +4174,18 @@
         if (frames && frames[_DYN_LENGTH$1 ] > 0) {
             parsedStack = [];
             var level_1 = 0;
+            var foundStackStart_1 = false;
             var totalSizeInBytes_1 = 0;
             arrForEach(frames, function (frame) {
-                var theFrame = frame[_DYN_TO_STRING$1 ]();
-                if (_StackFrame.regex.test(theFrame)) {
-                    var parsedFrame = new _StackFrame(theFrame, level_1++);
-                    totalSizeInBytes_1 += parsedFrame[_DYN_SIZE_IN_BYTES ];
-                    parsedStack[_DYN_PUSH ](parsedFrame);
+                if (foundStackStart_1 || _isStackFrame(frame)) {
+                    var theFrame = asString(frame);
+                    foundStackStart_1 = true;
+                    var parsedFrame = _extractStackFrame(theFrame, level_1);
+                    if (parsedFrame) {
+                        totalSizeInBytes_1 += parsedFrame[_DYN_SIZE_IN_BYTES ];
+                        parsedStack[_DYN_PUSH ](parsedFrame);
+                        level_1++;
+                    }
                 }
             });
             var exceptionParsedStackThreshold = 32 * 1024;
@@ -4247,7 +4271,7 @@
                 if (id) {
                     properties.id = id;
                 }
-                _self[_DYN_EXCEPTIONS ] = [new _ExceptionDetails(logger, exception, properties)];
+                _self[_DYN_EXCEPTIONS ] = [_createExceptionDetails(logger, exception, properties)];
                 _self[_DYN_PROPERTIES$1 ] = dataSanitizeProperties(logger, properties);
                 _self[_DYN_MEASUREMENTS ] = dataSanitizeMeasurements(logger, measurements);
                 if (severityLevel) {
@@ -4293,7 +4317,7 @@
         };
         Exception.CreateFromInterface = function (logger, exception, properties, measurements) {
             var exceptions = exception[_DYN_EXCEPTIONS ]
-                && arrMap(exception[_DYN_EXCEPTIONS ], function (ex) { return _ExceptionDetails[_DYN__CREATE_FROM_INTERFA1 ](logger, ex); });
+                && arrMap(exception[_DYN_EXCEPTIONS ], function (ex) { return _createExDetailsFromInterface(logger, ex); });
             var exceptionData = new Exception(logger, __assignFn(__assignFn({}, exception), { exceptions: exceptions }), properties, measurements);
             return exceptionData;
         };
@@ -4333,131 +4357,218 @@
         Exception.formatError = _formatErrorCode;
         return Exception;
     }());
-    var _ExceptionDetails = /** @class */ (function () {
-        function _ExceptionDetails(logger, exception, properties) {
-            this.aiDataContract = {
-                id: 0 ,
-                outerId: 0 ,
-                typeName: 1 ,
-                message: 1 ,
-                hasFullStack: 0 ,
-                stack: 0 ,
-                parsedStack: 2
-            };
-            var _self = this;
-            if (!_isExceptionDetailsInternal(exception)) {
-                var error = exception;
-                var evt = error && error.evt;
-                if (!isError(error)) {
-                    error = error[strError] || evt || error;
-                }
-                _self[_DYN_TYPE_NAME ] = dataSanitizeString(logger, _getErrorType(error)) || strNotSpecified;
-                _self[_DYN_MESSAGE$1 ] = dataSanitizeMessage(logger, _formatMessage(exception || error, _self[_DYN_TYPE_NAME ])) || strNotSpecified;
-                var stack = exception[strStackDetails] || _getStackFromErrorObj(exception);
-                _self[_DYN_PARSED_STACK ] = _parseStack(stack);
-                if (isArray(_self[_DYN_PARSED_STACK ])) {
-                    arrMap(_self[_DYN_PARSED_STACK ], function (frame) {
-                        frame[_DYN_ASSEMBLY ] = dataSanitizeString(logger, frame[_DYN_ASSEMBLY ]);
-                        frame[_DYN_FILE_NAME ] = dataSanitizeString(logger, frame[_DYN_FILE_NAME ]);
-                    });
-                }
-                _self[strStack] = dataSanitizeException(logger, _formatStackTrace(stack));
-                _self.hasFullStack = isArray(_self.parsedStack) && _self.parsedStack[_DYN_LENGTH$1 ] > 0;
-                if (properties) {
-                    properties[_DYN_TYPE_NAME ] = properties[_DYN_TYPE_NAME ] || _self[_DYN_TYPE_NAME ];
-                }
+    var exDetailsAiDataContract = objFreeze({
+        id: 0 ,
+        outerId: 0 ,
+        typeName: 1 ,
+        message: 1 ,
+        hasFullStack: 0 ,
+        stack: 0 ,
+        parsedStack: 2
+    });
+    function _toInterface() {
+        var _a;
+        var _self = this;
+        var parsedStack = isArray(_self[_DYN_PARSED_STACK ])
+            && arrMap(_self[_DYN_PARSED_STACK ], function (frame) { return _parsedFrameToInterface(frame); });
+        var exceptionDetailsInterface = (_a = {
+                id: _self.id,
+                outerId: _self.outerId,
+                typeName: _self[_DYN_TYPE_NAME ],
+                message: _self[_DYN_MESSAGE$1 ],
+                hasFullStack: _self[_DYN_HAS_FULL_STACK ],
+                stack: _self[strStack]
+            },
+            _a[_DYN_PARSED_STACK ] = parsedStack || undefined,
+            _a);
+        return exceptionDetailsInterface;
+    }
+    function _createExceptionDetails(logger, exception, properties) {
+        var _a;
+        var id;
+        var outerId;
+        var typeName;
+        var message;
+        var hasFullStack;
+        var theStack;
+        var parsedStack;
+        if (!_isExceptionDetailsInternal(exception)) {
+            var error = exception;
+            var evt = error && error.evt;
+            if (!isError(error)) {
+                error = error[strError] || evt || error;
+            }
+            typeName = dataSanitizeString(logger, _getErrorType(error)) || strNotSpecified;
+            message = dataSanitizeMessage(logger, _formatMessage(exception || error, typeName)) || strNotSpecified;
+            var stack = exception[strStackDetails] || _getStackFromErrorObj(exception);
+            parsedStack = _parseStack(stack);
+            if (isArray(parsedStack)) {
+                arrMap(parsedStack, function (frame) {
+                    frame[_DYN_ASSEMBLY ] = dataSanitizeString(logger, frame[_DYN_ASSEMBLY ]);
+                    frame[_DYN_FILE_NAME ] = dataSanitizeString(logger, frame[_DYN_FILE_NAME ]);
+                });
+            }
+            theStack = dataSanitizeException(logger, _formatStackTrace(stack));
+            hasFullStack = isArray(parsedStack) && parsedStack[_DYN_LENGTH$1 ] > 0;
+            if (properties) {
+                properties[_DYN_TYPE_NAME ] = properties[_DYN_TYPE_NAME ] || typeName;
+            }
+        }
+        else {
+            typeName = exception[_DYN_TYPE_NAME ];
+            message = exception[_DYN_MESSAGE$1 ];
+            theStack = exception[strStack];
+            parsedStack = exception[_DYN_PARSED_STACK ] || [];
+            hasFullStack = exception[_DYN_HAS_FULL_STACK ];
+        }
+        return _a = {},
+            _a[_DYN_AI_DATA_CONTRACT ] = exDetailsAiDataContract,
+            _a.id = id,
+            _a.outerId = outerId,
+            _a[_DYN_TYPE_NAME ] = typeName,
+            _a[_DYN_MESSAGE$1 ] = message,
+            _a[_DYN_HAS_FULL_STACK ] = hasFullStack,
+            _a.stack = theStack,
+            _a[_DYN_PARSED_STACK ] = parsedStack,
+            _a.toInterface = _toInterface,
+            _a;
+    }
+    function _createExDetailsFromInterface(logger, exception) {
+        var parsedStack = (isArray(exception[_DYN_PARSED_STACK ])
+            && arrMap(exception[_DYN_PARSED_STACK ], function (frame) { return _stackFrameFromInterface(frame); }))
+            || exception[_DYN_PARSED_STACK ];
+        var exceptionDetails = _createExceptionDetails(logger, __assignFn(__assignFn({}, exception), { parsedStack: parsedStack }));
+        return exceptionDetails;
+    }
+    function _parseFilename(theFrame, fileName) {
+        var lineCol = fileName[_DYN_MATCH ](PARSE_FILENAME_LINE_COL);
+        if (lineCol && lineCol[_DYN_LENGTH$1 ] >= 4) {
+            theFrame[_DYN_FILE_NAME ] = lineCol[1];
+            theFrame[_DYN_LINE ] = parseInt(lineCol[2]);
+        }
+        else {
+            var lineNo = fileName[_DYN_MATCH ](PARSE_FILENAME_LINE_ONLY);
+            if (lineNo && lineNo[_DYN_LENGTH$1 ] >= 3) {
+                theFrame[_DYN_FILE_NAME ] = lineNo[1];
+                theFrame[_DYN_LINE ] = parseInt(lineNo[2]);
             }
             else {
-                _self[_DYN_TYPE_NAME ] = exception[_DYN_TYPE_NAME ];
-                _self[_DYN_MESSAGE$1 ] = exception[_DYN_MESSAGE$1 ];
-                _self[strStack] = exception[strStack];
-                _self[_DYN_PARSED_STACK ] = exception[_DYN_PARSED_STACK ] || [];
-                _self[_DYN_HAS_FULL_STACK ] = exception[_DYN_HAS_FULL_STACK ];
+                theFrame[_DYN_FILE_NAME ] = fileName;
             }
         }
-        _ExceptionDetails.prototype.toInterface = function () {
-            var _a;
-            var _self = this;
-            var parsedStack = _self[_DYN_PARSED_STACK ] instanceof Array
-                && arrMap(_self[_DYN_PARSED_STACK ], function (frame) { return frame.toInterface(); });
-            var exceptionDetailsInterface = (_a = {
-                    id: _self.id,
-                    outerId: _self.outerId,
-                    typeName: _self[_DYN_TYPE_NAME ],
-                    message: _self[_DYN_MESSAGE$1 ],
-                    hasFullStack: _self[_DYN_HAS_FULL_STACK ],
-                    stack: _self[strStack]
-                },
-                _a[_DYN_PARSED_STACK ] = parsedStack || undefined,
+    }
+    function _handleFilename(theFrame, sequence, matches) {
+        var filename = theFrame[_DYN_FILE_NAME ];
+        if (sequence.fn && matches && matches[_DYN_LENGTH$1 ] > sequence.fn) {
+            if (sequence.ln && matches[_DYN_LENGTH$1 ] > sequence.ln) {
+                filename = strTrim(matches[sequence.fn] || "");
+                theFrame[_DYN_LINE ] = parseInt(strTrim(matches[sequence.ln] || "")) || 0;
+            }
+            else {
+                filename = strTrim(matches[sequence.fn] || "");
+            }
+        }
+        if (filename) {
+            _parseFilename(theFrame, filename);
+        }
+    }
+    function _isStackFrame(frame) {
+        var result = false;
+        if (frame && isString(frame)) {
+            var trimmedFrame = strTrim(frame);
+            if (trimmedFrame) {
+                result = IS_FRAME.test(trimmedFrame);
+            }
+        }
+        return result;
+    }
+    var stackFrameAiDataContract = objFreeze({
+        level: 1 ,
+        method: 1 ,
+        assembly: 0 ,
+        fileName: 0 ,
+        line: 0
+    });
+    function _extractStackFrame(frame, level) {
+        var _a;
+        var theFrame;
+        if (frame && isString(frame) && strTrim(frame)) {
+            theFrame = (_a = {},
+                _a[_DYN_AI_DATA_CONTRACT ] = stackFrameAiDataContract,
+                _a[_DYN_LEVEL ] = level,
+                _a[_DYN_ASSEMBLY ] = strTrim(frame),
+                _a[_DYN_METHOD ] = NoMethod,
+                _a.fileName = "",
+                _a.line = 0,
+                _a[_DYN_SIZE_IN_BYTES ] = 0,
                 _a);
-            return exceptionDetailsInterface;
-        };
-        _ExceptionDetails.CreateFromInterface = function (logger, exception) {
-            var parsedStack = (exception[_DYN_PARSED_STACK ] instanceof Array
-                && arrMap(exception[_DYN_PARSED_STACK ], function (frame) { return _StackFrame[_DYN__CREATE_FROM_INTERFA1 ](frame); }))
-                || exception[_DYN_PARSED_STACK ];
-            var exceptionDetails = new _ExceptionDetails(logger, __assignFn(__assignFn({}, exception), { parsedStack: parsedStack }));
-            return exceptionDetails;
-        };
-        return _ExceptionDetails;
-    }());
-    var _StackFrame = /** @class */ (function () {
-        function _StackFrame(sourceFrame, level) {
-            this.aiDataContract = {
-                level: 1 ,
-                method: 1 ,
-                assembly: 0 ,
-                fileName: 0 ,
-                line: 0
-            };
-            var _self = this;
-            _self[_DYN_SIZE_IN_BYTES ] = 0;
-            if (typeof sourceFrame === "string") {
-                var frame = sourceFrame;
-                _self[_DYN_LEVEL ] = level;
-                _self[_DYN_METHOD ] = NoMethod;
-                _self[_DYN_ASSEMBLY ] = strTrim(frame);
-                _self[_DYN_FILE_NAME ] = "";
-                _self[_DYN_LINE ] = 0;
-                var matches = frame.match(_StackFrame.regex);
-                if (matches && matches[_DYN_LENGTH$1 ] >= 5) {
-                    _self[_DYN_METHOD ] = strTrim(matches[2]) || _self[_DYN_METHOD ];
-                    _self[_DYN_FILE_NAME ] = strTrim(matches[4]);
-                    _self[_DYN_LINE ] = parseInt(matches[5]) || 0;
+            var idx = 0;
+            while (idx < _parseSequence[_DYN_LENGTH$1 ]) {
+                var sequence = _parseSequence[idx];
+                if (sequence.chk && !sequence.chk(frame)) {
+                    break;
+                }
+                if (sequence.pre) {
+                    frame = sequence.pre(frame);
                 }
+                var matches = frame[_DYN_MATCH ](sequence.re);
+                if (matches && matches[_DYN_LENGTH$1 ] >= sequence.len) {
+                    if (sequence.m) {
+                        theFrame[_DYN_METHOD ] = strTrim(matches[sequence.m] || NoMethod);
+                    }
+                    if (sequence.hdl) {
+                        sequence.hdl(theFrame, sequence, matches);
+                    }
+                    else if (sequence.fn) {
+                        if (sequence.ln) {
+                            theFrame[_DYN_FILE_NAME ] = strTrim(matches[sequence.fn] || "");
+                            theFrame[_DYN_LINE ] = parseInt(strTrim(matches[sequence.ln] || "")) || 0;
+                        }
+                        else {
+                            _parseFilename(theFrame, matches[sequence.fn] || "");
+                        }
+                    }
+                    break;
+                }
+                idx++;
             }
-            else {
-                _self[_DYN_LEVEL ] = sourceFrame[_DYN_LEVEL ];
-                _self[_DYN_METHOD ] = sourceFrame[_DYN_METHOD ];
-                _self[_DYN_ASSEMBLY ] = sourceFrame[_DYN_ASSEMBLY ];
-                _self[_DYN_FILE_NAME ] = sourceFrame[_DYN_FILE_NAME ];
-                _self[_DYN_LINE ] = sourceFrame[_DYN_LINE ];
-                _self[_DYN_SIZE_IN_BYTES ] = 0;
-            }
-            _self.sizeInBytes += _self.method[_DYN_LENGTH$1 ];
-            _self.sizeInBytes += _self.fileName[_DYN_LENGTH$1 ];
-            _self.sizeInBytes += _self.assembly[_DYN_LENGTH$1 ];
-            _self[_DYN_SIZE_IN_BYTES ] += _StackFrame.baseSize;
-            _self.sizeInBytes += _self.level.toString()[_DYN_LENGTH$1 ];
-            _self.sizeInBytes += _self.line.toString()[_DYN_LENGTH$1 ];
-        }
-        _StackFrame.CreateFromInterface = function (frame) {
-            return new _StackFrame(frame, null );
-        };
-        _StackFrame.prototype.toInterface = function () {
-            var _self = this;
-            return {
-                level: _self[_DYN_LEVEL ],
-                method: _self[_DYN_METHOD ],
-                assembly: _self[_DYN_ASSEMBLY ],
-                fileName: _self[_DYN_FILE_NAME ],
-                line: _self[_DYN_LINE ]
-            };
+        }
+        return _populateFrameSizeInBytes(theFrame);
+    }
+    function _stackFrameFromInterface(frame) {
+        var _a;
+        var parsedFrame = (_a = {},
+            _a[_DYN_AI_DATA_CONTRACT ] = stackFrameAiDataContract,
+            _a.level = frame[_DYN_LEVEL ],
+            _a.method = frame[_DYN_METHOD ],
+            _a.assembly = frame[_DYN_ASSEMBLY ],
+            _a.fileName = frame[_DYN_FILE_NAME ],
+            _a.line = frame[_DYN_LINE ],
+            _a[_DYN_SIZE_IN_BYTES ] = 0,
+            _a);
+        return _populateFrameSizeInBytes(parsedFrame);
+    }
+    function _populateFrameSizeInBytes(frame) {
+        var sizeInBytes = STACKFRAME_BASE_SIZE;
+        if (frame) {
+            sizeInBytes += frame.method[_DYN_LENGTH$1 ];
+            sizeInBytes += frame.assembly[_DYN_LENGTH$1 ];
+            sizeInBytes += frame.fileName[_DYN_LENGTH$1 ];
+            sizeInBytes += frame.level.toString()[_DYN_LENGTH$1 ];
+            sizeInBytes += frame.line.toString()[_DYN_LENGTH$1 ];
+            frame[_DYN_SIZE_IN_BYTES ] = sizeInBytes;
+        }
+        return frame;
+    }
+    function _parsedFrameToInterface(frame) {
+        return {
+            level: frame[_DYN_LEVEL ],
+            method: frame[_DYN_METHOD ],
+            assembly: frame[_DYN_ASSEMBLY ],
+            fileName: frame[_DYN_FILE_NAME ],
+            line: frame[_DYN_LINE ]
         };
-        _StackFrame.regex = /^([\s]+at)?[\s]{0,50}([^\@\()]+?)[\s]{0,50}(\@|\()([^\(\n]+):([0-9]+):([0-9]+)(\)?)$/;
-        _StackFrame.baseSize = 58;
-        return _StackFrame;
-    }());
+    }
 
     var DataPoint = /** @class */ (function () {
         function DataPoint() {
@@ -4732,24 +4843,25 @@
     var _DYN__CREATE_AUTO_EXCEPTI6 = "CreateAutoException";
     var _DYN_ADD_TELEMETRY_INITIA7 = "addTelemetryInitializer";
     var _DYN_OVERRIDE_PAGE_VIEW_D8 = "overridePageViewDuration";
-    var _DYN_AUTO_TRACK_PAGE_VISI9 = "autoTrackPageVisitTime";
-    var _DYN_IS_BROWSER_LINK_TRAC10 = "isBrowserLinkTrackingEnabled";
+    var _DYN_AUTO_EXCEPTION_INSTR9 = "autoExceptionInstrumented";
+    var _DYN_AUTO_TRACK_PAGE_VISI10 = "autoTrackPageVisitTime";
+    var _DYN_IS_BROWSER_LINK_TRAC11 = "isBrowserLinkTrackingEnabled";
     var _DYN_LENGTH = "length";
-    var _DYN_ENABLE_AUTO_ROUTE_TR11 = "enableAutoRouteTracking";
-    var _DYN_ENABLE_UNHANDLED_PRO12 = "enableUnhandledPromiseRejectionTracking";
-    var _DYN_AUTO_UNHANDLED_PROMI13 = "autoUnhandledPromiseInstrumented";
+    var _DYN_ENABLE_AUTO_ROUTE_TR12 = "enableAutoRouteTracking";
+    var _DYN_ENABLE_UNHANDLED_PRO13 = "enableUnhandledPromiseRejectionTracking";
+    var _DYN_AUTO_UNHANDLED_PROMI14 = "autoUnhandledPromiseInstrumented";
     var _DYN_GET_ENTRIES_BY_TYPE = "getEntriesByType";
-    var _DYN_IS_PERFORMANCE_TIMIN14 = "isPerformanceTimingSupported";
-    var _DYN_GET_PERFORMANCE_TIMI15 = "getPerformanceTiming";
+    var _DYN_IS_PERFORMANCE_TIMIN15 = "isPerformanceTimingSupported";
+    var _DYN_GET_PERFORMANCE_TIMI16 = "getPerformanceTiming";
     var _DYN_NAVIGATION_START = "navigationStart";
-    var _DYN_SHOULD_COLLECT_DURAT16 = "shouldCollectDuration";
-    var _DYN_IS_PERFORMANCE_TIMIN17 = "isPerformanceTimingDataReady";
+    var _DYN_SHOULD_COLLECT_DURAT17 = "shouldCollectDuration";
+    var _DYN_IS_PERFORMANCE_TIMIN18 = "isPerformanceTimingDataReady";
     var _DYN_RESPONSE_START = "responseStart";
     var _DYN_REQUEST_START = "requestStart";
     var _DYN_LOAD_EVENT_END = "loadEventEnd";
     var _DYN_RESPONSE_END = "responseEnd";
     var _DYN_CONNECT_END = "connectEnd";
-    var _DYN_PAGE_VISIT_START_TIM18 = "pageVisitStartTime";
+    var _DYN_PAGE_VISIT_START_TIM19 = "pageVisitStartTime";
 
     var PageViewManager = /** @class */ (function () {
         function PageViewManager(appInsights, overridePageViewDuration, core, pageViewPerformanceManager) {
@@ -4820,7 +4932,7 @@
                         }
                         firstPageViewSent = true;
                     }
-                    if (!pageViewPerformanceManager[_DYN_IS_PERFORMANCE_TIMIN14 ]()) {
+                    if (!pageViewPerformanceManager[_DYN_IS_PERFORMANCE_TIMIN15 ]()) {
                         appInsights[_DYN_SEND_PAGE_VIEW_INTER2 ](pageView, customProperties);
                         _flushChannels(true);
                         if (!isWebWorker()) {
@@ -4830,10 +4942,10 @@
                     }
                     var pageViewSent = false;
                     var customDuration;
-                    var start = pageViewPerformanceManager[_DYN_GET_PERFORMANCE_TIMI15 ]()[_DYN_NAVIGATION_START ];
+                    var start = pageViewPerformanceManager[_DYN_GET_PERFORMANCE_TIMI16 ]()[_DYN_NAVIGATION_START ];
                     if (start > 0) {
                         customDuration = dateTimeUtilsDuration(start, +new Date);
-                        if (!pageViewPerformanceManager[_DYN_SHOULD_COLLECT_DURAT16 ](customDuration)) {
+                        if (!pageViewPerformanceManager[_DYN_SHOULD_COLLECT_DURAT17 ](customDuration)) {
                             customDuration = undefined;
                         }
                     }
@@ -4860,7 +4972,7 @@
                     _addQueue(function () {
                         var processed = false;
                         try {
-                            if (pageViewPerformanceManager[_DYN_IS_PERFORMANCE_TIMIN17 ]()) {
+                            if (pageViewPerformanceManager[_DYN_IS_PERFORMANCE_TIMIN18 ]()) {
                                 processed = true;
                                 var pageViewPerformance = {
                                     name: name,
@@ -5004,7 +5116,7 @@
                         if (total === 0) {
                             _throwInternal(_logger, 2 , 10 , "error calculating page view performance.", { total: total, network: network, request: request, response: response, dom: dom });
                         }
-                        else if (!_self[_DYN_SHOULD_COLLECT_DURAT16 ](total, network, request, response, dom)) {
+                        else if (!_self[_DYN_SHOULD_COLLECT_DURAT17 ](total, network, request, response, dom)) {
                             _throwInternal(_logger, 2 , 45 , "Invalid page load duration value. Browser perf data won't be sent.", { total: total, network: network, request: request, response: response, dom: dom });
                         }
                         else if (total < Math.floor(network) + Math.floor(request) + Math.floor(response) + Math.floor(dom)) {
@@ -5021,10 +5133,10 @@
                         }
                     }
                 };
-                _self[_DYN_GET_PERFORMANCE_TIMI15 ] = _getPerformanceTiming;
-                _self[_DYN_IS_PERFORMANCE_TIMIN14 ] = _isPerformanceTimingSupported;
-                _self[_DYN_IS_PERFORMANCE_TIMIN17 ] = _isPerformanceTimingDataReady;
-                _self[_DYN_SHOULD_COLLECT_DURAT16 ] = _shouldCollectDuration;
+                _self[_DYN_GET_PERFORMANCE_TIMI16 ] = _getPerformanceTiming;
+                _self[_DYN_IS_PERFORMANCE_TIMIN15 ] = _isPerformanceTimingSupported;
+                _self[_DYN_IS_PERFORMANCE_TIMIN18 ] = _isPerformanceTimingDataReady;
+                _self[_DYN_SHOULD_COLLECT_DURAT17 ] = _shouldCollectDuration;
             });
         }
         PageViewPerformanceManager.__ieDyn=1;
@@ -5072,7 +5184,7 @@
                             var pageVisitDataJsonStr = utlGetSessionStorage(logger, prevPageVisitDataKeyName);
                             if (pageVisitDataJsonStr && hasJSON()) {
                                 prevPageVisitData = getJSON().parse(pageVisitDataJsonStr);
-                                prevPageVisitData.pageVisitTime = pageVisitEndTime - prevPageVisitData[_DYN_PAGE_VISIT_START_TIM18 ];
+                                prevPageVisitData.pageVisitTime = pageVisitEndTime - prevPageVisitData[_DYN_PAGE_VISIT_START_TIM19 ];
                                 utlRemoveSessionStorage(logger, prevPageVisitDataKeyName);
                             }
                         }
@@ -5092,7 +5204,7 @@
     }());
     var PageVisitData = /** @class */ (function () {
         function PageVisitData(pageName, pageUrl) {
-            this[_DYN_PAGE_VISIT_START_TIM18 ] = utcNow();
+            this[_DYN_PAGE_VISIT_START_TIM19 ] = utcNow();
             this.pageName = pageName;
             this.pageUrl = pageUrl;
         }
@@ -5149,14 +5261,14 @@
             sessionExpirationMs: cfgDfSet(_chkConfigMilliseconds, 24 * 60 * 60 * 1000),
             disableExceptionTracking: cfgDfBoolean()
         },
-        _a[_DYN_AUTO_TRACK_PAGE_VISI9 ] = cfgDfBoolean(),
+        _a[_DYN_AUTO_TRACK_PAGE_VISI10 ] = cfgDfBoolean(),
         _a[_DYN_OVERRIDE_PAGE_VIEW_D8 ] = cfgDfBoolean(),
-        _a[_DYN_ENABLE_UNHANDLED_PRO12 ] = cfgDfBoolean(),
-        _a[_DYN_AUTO_UNHANDLED_PROMI13 ] = false,
+        _a[_DYN_ENABLE_UNHANDLED_PRO13 ] = cfgDfBoolean(),
+        _a[_DYN_AUTO_UNHANDLED_PROMI14 ] = false,
         _a.samplingPercentage = cfgDfValidate(_chkSampling, 100),
         _a[_DYN_IS_STORAGE_USE_DISAB0 ] = cfgDfBoolean(),
-        _a[_DYN_IS_BROWSER_LINK_TRAC10 ] = cfgDfBoolean(),
-        _a[_DYN_ENABLE_AUTO_ROUTE_TR11 ] = cfgDfBoolean(),
+        _a[_DYN_IS_BROWSER_LINK_TRAC11 ] = cfgDfBoolean(),
+        _a[_DYN_ENABLE_AUTO_ROUTE_TR12 ] = cfgDfBoolean(),
         _a.namePrefix = cfgDfString(),
         _a.enableDebug = cfgDfBoolean(),
         _a.disableFlushOnBeforeUnload = cfgDfBoolean(),
@@ -5210,6 +5322,7 @@
             var _prevUri;
             var _currUri;
             var _evtNamespace;
+            var _errorHookCnt;
             dynamicProto(AnalyticsPlugin, _this, function (_self, _base) {
                 var _addHook = _base[_DYN__ADD_HOOK ];
                 _initDefaults();
@@ -5467,19 +5580,23 @@
                     eventOff(window, null, null, _evtNamespace);
                     _initDefaults();
                 };
+                _self["_getDbgPlgTargets"] = function () {
+                    return [_errorHookCnt, _autoExceptionInstrumented];
+                };
                 function _populateDefaults(config) {
                     var identifier = _self.identifier;
                     var core = _self[_DYN_CORE ];
                     _self[_DYN__ADD_HOOK ](onConfigChange(config, function () {
                         var ctx = createProcessTelemetryContext(null, config, core);
                         _extConfig = ctx.getExtCfg(identifier, defaultValues);
+                        _autoExceptionInstrumented = _autoExceptionInstrumented || config[_DYN_AUTO_EXCEPTION_INSTR9 ] || _extConfig[_DYN_AUTO_EXCEPTION_INSTR9 ];
                         _expCfg = _extConfig.expCfg;
-                        _autoTrackPageVisitTime = _extConfig[_DYN_AUTO_TRACK_PAGE_VISI9 ];
+                        _autoTrackPageVisitTime = _extConfig[_DYN_AUTO_TRACK_PAGE_VISI10 ];
                         if (config.storagePrefix) {
                             utlSetStoragePrefix(config.storagePrefix);
                         }
                         _updateStorageUsage(_extConfig);
-                        _isBrowserLinkTrackingEnabled = _extConfig[_DYN_IS_BROWSER_LINK_TRAC10 ];
+                        _isBrowserLinkTrackingEnabled = _extConfig[_DYN_IS_BROWSER_LINK_TRAC11 ];
                         _addDefaultTelemetryInitializers();
                     }));
                 }
@@ -5522,7 +5639,7 @@
                     var locn = getLocation(true);
                     _self[_DYN__ADD_HOOK ](onConfigChange(_extConfig, function () {
                         _disableExceptionTracking = _extConfig.disableExceptionTracking;
-                        if (!_disableExceptionTracking && !_autoExceptionInstrumented && !_extConfig.autoExceptionInstrumented) {
+                        if (!_disableExceptionTracking && !_autoExceptionInstrumented && !_extConfig[_DYN_AUTO_EXCEPTION_INSTR9 ]) {
                             _addHook(InstrumentEvent(_window, "onerror", {
                                 ns: _evtNamespace,
                                 rsp: function (callDetails, message, url, lineNumber, columnNumber, error) {
@@ -5531,6 +5648,7 @@
                                     }
                                 }
                             }, false));
+                            _errorHookCnt++;
                             _autoExceptionInstrumented = true;
                         }
                     }));
@@ -5540,7 +5658,7 @@
                     var win = getWindow();
                     var locn = getLocation(true);
                     _self[_DYN__ADD_HOOK ](onConfigChange(_extConfig, function () {
-                        _enableAutoRouteTracking = _extConfig[_DYN_ENABLE_AUTO_ROUTE_TR11 ] === true;
+                        _enableAutoRouteTracking = _extConfig[_DYN_ENABLE_AUTO_ROUTE_TR12 ] === true;
                         if (win && _enableAutoRouteTracking && !_historyListenerAdded && hasHistory()) {
                             var _history = getHistory();
                             if (isFunction(_history.pushState) && isFunction(_history.replaceState) && typeof Event !== strShimUndefined) {
@@ -5622,8 +5740,8 @@
                 }
                 function _addUnhandledPromiseRejectionTracking(_window, _location) {
                     _self[_DYN__ADD_HOOK ](onConfigChange(_extConfig, function () {
-                        _enableUnhandledPromiseRejectionTracking = _extConfig[_DYN_ENABLE_UNHANDLED_PRO12 ] === true;
-                        _autoExceptionInstrumented = _autoExceptionInstrumented || _extConfig[_DYN_AUTO_UNHANDLED_PROMI13 ];
+                        _enableUnhandledPromiseRejectionTracking = _extConfig[_DYN_ENABLE_UNHANDLED_PRO13 ] === true;
+                        _autoExceptionInstrumented = _autoExceptionInstrumented || _extConfig[_DYN_AUTO_UNHANDLED_PROMI14 ];
                         if (_enableUnhandledPromiseRejectionTracking && !_autoUnhandledPromiseInstrumented) {
                             _addHook(InstrumentEvent(_window, "onunhandledrejection", {
                                 ns: _evtNamespace,
@@ -5633,7 +5751,8 @@
                                     }
                                 }
                             }, false));
-                            _extConfig[_DYN_AUTO_UNHANDLED_PROMI13 ] = _autoUnhandledPromiseInstrumented = true;
+                            _errorHookCnt++;
+                            _extConfig[_DYN_AUTO_UNHANDLED_PROMI14 ] = _autoUnhandledPromiseInstrumented = true;
                         }
                     }));
                 }
@@ -5661,6 +5780,7 @@
                     _currUri = null;
                     _evtNamespace = null;
                     _extConfig = null;
+                    _errorHookCnt = 0;
                     objDefine(_self, "config", {
                         g: function () { return _extConfig; }
                     });
@@ -5672,7 +5792,7 @@
             });
             return _this;
         }
-        AnalyticsPlugin.Version = '3.3.5-nightly3.2501-07';
+        AnalyticsPlugin.Version = '3.3.5-nightly3.2502-02';
         return AnalyticsPlugin;
     }(BaseTelemetryPlugin));