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 156 matching lines @@
   }
 }
 
 class MappingBundle extends Mapping {
   Map<String, SingleMapping> _mappings = {};
 
   MappingBundle.fromJson(List json, {String mapUrl}) {
     for (var map in json) {
       var mapping = parseJson(map, mapUrl: mapUrl) as SingleMapping;
       var targetUrl = mapping.targetUrl;
+      // TODO(jacobr): verify that targetUrl is valid uri instead of a windows
+      // path.
       _mappings[targetUrl] = mapping;
     }
   }
 
   /// Encodes the Mapping mappings as a json map.
   List toJson() => _mappings.values.map((v) => v.toJson()).toList();
 
   String toString() {
     var buff = new StringBuffer();
     for (var map in _mappings.values) {
       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 can be handled 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)];
+    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);
+        }
+      }
+      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});
 }