Rev package version as the extended source map format is a new feature.

lib/parser.dart

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 /// Contains the top-level function to parse source maps version 3.
 library source_maps.parser;
 
 import 'dart:collection';
 import 'dart:convert';
 
-import 'package:path/path.dart' as path;
 import 'package:source_span/source_span.dart';
 
 import 'builder.dart' as builder;
 import 'src/source_map_span.dart';
 import 'src/utils.dart';
 import 'src/vlq.dart';
 
 /// Parses a source map directly from a json string.
 ///
 /// [mapUrl], which may be either a [String] or a [Uri], indicates the URL of
@@ skipping 176 matching lines @@
       buff.write(map.toString());
     }
     return buff.toString();
   }
 
   SourceMapSpan spanFor(int line, int column,
       {Map<String, SourceFile> files, String uri}) {
     if (uri == null) {
       throw new ArgumentError.notNull('uri');
     }
-    if (_mappings.containsKey(uri)) {
-      return _mappings[uri].spanFor(line, column, files: files, uri: uri);
-    }
-    // Fall back to looking up the source map on just the basename.
-    var name = path.basename(uri.toString());
-    if (_mappings.containsKey(name)) {
-      return _mappings[name].spanFor(line, column, files: files, uri: name);
+
+    // Find the longest suffix of the uri that matches the sourcemap
+    // where the suffix starts after a path segment boundary.
+    // We consider ":", "/", and "\" as path segment boundaries so that
+    // "package:" uris, windows paths, and linux paths can all be handled
+    // properly with minimal special casing. Having a few false positive
+    // path segment boundaries is not a significant issue as we prefer the
+    // longest matching prefix.
+    // Using package:path `path.split` to find path segment boundaries would
+    // not generate all of the path segment boundaries we want for package:
+    // urls as "package:package_name" would be one path segment when we want
+    // "package" and "package_name" to be sepearate path segments.
+
+    bool onBoundary = true;
+    var separatorCodeUnits = [
+      '/'.codeUnitAt(0),
+      '\\'.codeUnitAt(0),

[Siggi Cherem (dart-lang), 2016/12/14 19:10:34]

we discussed this offline: let's get rid of the handling of backslashes here and
add ensure that the input is normalized, so that what we look up here has to
match what was given to us in MappingBundle.fromJson(...);

[Jacob, 2016/12/14 19:17:00]

Done.

+      ':'.codeUnitAt(0)
+    ];
+    for (var i = 0; i < uri.length; ++i) {
+      if (onBoundary) {
+        var candidate = uri.substring(i);
+        if (_mappings.containsKey(candidate)) {
+          return _mappings[candidate]
+              .spanFor(line, column, files: files, uri: candidate);
+        }
+        // The following two cases are needed to handle cases where the uri
+        // may use different path separator conventions that the source map
+        // bundle as is seasonable if we are using the source map bundle on
+        // the server while the files being considered are on the client.
+
+        var webCandidate = candidate.replaceAll('\\', '/');
+        if (_mappings.containsKey(webCandidate)) {
+          return _mappings[webCandidate]
+              .spanFor(line, column, files: files, uri: webCandidate);
+        }
+
+        var windowsCandidate = candidate.replaceAll('/', '\\');
+        if (_mappings.containsKey(windowsCandidate)) {
+          return _mappings[windowsCandidate]
+              .spanFor(line, column, files: files, uri: windowsCandidate);
+        }
+      }
+      onBoundary = separatorCodeUnits.contains(uri.codeUnitAt(i));
     }
 
     // Note: when there is no source map for an uri, this behaves like an
     // identity function, returning the requested location as the result.
 
     // Create a mock offset for the output location. We compute it in terms
     // of the input line and column to minimize the chances that two different
     // line and column locations are mapped to the same offset.
     var offset = line * 1000000 + column;
     var location = new SourceLocation(offset,
@@ skipping 386 matching lines @@
   static const _TokenKind EOF = const _TokenKind(isEof: true);
   static const _TokenKind VALUE = const _TokenKind();
   final bool isNewLine;
   final bool isNewSegment;
   final bool isEof;
   bool get isValue => !isNewLine && !isNewSegment && !isEof;
 
   const _TokenKind(
       {this.isNewLine: false, this.isNewSegment: false, this.isEof: false});
 }