Larrifax's response is well done, but there exists an enhanced iteration of the function detailed within the corresponding issue report:

.config(function($provide) {

  // Correcting sourcemaps
  // @url https://github.com/angular/angular.js/issues/5217#issuecomment-50993513
  $provide.decorator('$exceptionHandler', function($delegate) {
    return function(exception, cause) {
      $delegate(exception, cause);
      setTimeout(function() {
        throw exception;
      });
    };
  });
})

This script will result in two stack traces, as acknowledged by Andrew Magee here: one structured by Angular, followed by a second one formatted by the browser. The subsequent trace incorporates sourcemaps. It may not be advisable to deactivate the duplicates, since you could potentially have other Angular modules that also manage exceptions and might get invoked subsequently through delegation.

If you're facing a challenge and struggling to find a solution, sometimes the only option left is to roll up your sleeves and tackle the issue head-on. One way to address source map parsing is by diving into the code yourself. Here's a snippet that can help with this task. To begin, ensure that you have integrated source-map into your webpage. Then, implement the following code:

angular.module('Shared').factory('$exceptionHandler', 
function($log, $window, $injector) {
  var getSourceMappedStackTrace = function(exception) {
    var $q = $injector.get('$q'),
        $http = $injector.get('$http'),
        SMConsumer = window.sourceMap.SourceMapConsumer,
        cache = {};

    // Obtain a SourceMap object for a minified script URL
    var getMapForScript = function(url) {
      if (cache[url]) {
        return cache[url];
      } else {
        var promise = $http.get(url).then(function(response) {
          var m = response.data.match(/\/\/# sourceMappingURL=(.+\.map)/);
          if (m) {
            var path = url.match(/^(.+)\/[^/]+$/);
            path = path && path[1];
            return $http.get(path + '/' + m[1]).then(function(response) {
              return new SMConsumer(response.data);
            });
          } else {
            return $q.reject();
          }
        });
        cache[url] = promise;
        return promise;
      }
    };

    if (exception.stack) { // not all browsers support stack traces
      return $q.all(_.map(exception.stack.split(/\n/), function(stackLine) {
        var match = stackLine.match(/^(.+)(http.+):(\d+):(\d+)/);
        if (match) {
          var prefix = match[1], url = match[2], line = match[3], col = match[4];
          return getMapForScript(url).then(function(map) {
            var pos = map.originalPositionFor({
              line: parseInt(line, 10), 
              column: parseInt(col, 10)
            });
            var mangledName = prefix.match(/\s*(at)?\s*(.*?)\s*(\(|@)/);
            mangledName = (mangledName && mangledName[2]) || '';
            return '    at ' + (pos.name ? pos.name : mangledName) + ' ' + 
              $window.location.origin + pos.source + ':' + pos.line + ':' + 
              pos.column;
          }, function() {
            return stackLine;
          });
        } else {
          return $q.when(stackLine);
        }
      })).then(function (lines) {
        return lines.join('\n');
      });
    } else {
      return $q.when('');
    }
  };

  return function(exception) {
    getSourceMappedStackTrace(exception).then($log.error);
  };
});

This approach involves downloading the source, fetching the sourcemaps, parsing them, and replacing the locations in the stack trace with mapped locations. While this method functions well in Chrome and satisfactorily in Firefox, it does come with some drawbacks. You'll be introducing a significant dependency to your codebase and transitioning from swift synchronous error reporting to somewhat slower asynchronous error reporting.

I recently encountered the same problem and have been searching for a solution - turns out it's a Chrome issue related to stack traces in general, which also affects Angular due to its use of stack traces for error reporting. Check out this discussion on Stack Overflow:

Will the source mapping in Google Chrome push to Error.stack

For those interested in exploring further, I recommend checking out this project: https://github.com/novocaine/sourcemapped-stacktrace

This resource provides a similar solution to what @jakub-hampl suggested, offering additional functionality that could prove helpful.

As mentioned in this reported issue, it appears that Angular's usage of $logProvider can disrupt sourcemapping functionality. To address this, a workaround has been proposed:

var customModule = angular.module('source-map-exception-handler', [])

customModule.config(function($provide) {
  $provide.decorator('$exceptionHandler', function($delegate) {
    return function(exception, cause) {
        $delegate(exception, cause);
        throw exception;
    };
  });
});

While the bug in Chrome has been resolved, the problem still remains in Angular. To prevent printing out the stack trace twice, a temporary solution would be to implement the following:

app.factory('$exceptionHandler', function() {
    return function(exception, cause) {
        console.error(exception.stack);
    };
});