Use source_span rather than source_maps in csslib.

pkg/csslib/lib/parser.dart

 // Copyright (c) 2012, 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.
 
 library csslib.parser;
 
 import 'dart:math' as math;
 
-import 'package:source_maps/span.dart' show SourceFile, Span, FileSpan;
+import 'package:source_span/source_span.dart';
 
 import "visitor.dart";
 import 'src/messages.dart';
 import 'src/options.dart';
 
 part 'src/analyzer.dart';
 part 'src/polyfill.dart';
 part 'src/property.dart';
 part 'src/token.dart';
 part 'src/tokenizer_base.dart';
@@ skipping 32 matching lines @@
     List<StyleSheet> includes: null}) {
 
   if (includes == null) {
     includes = [];
   }
 
   var source = _inputAsString(input);
 
   _createMessages(errors: errors, options: options);
 
-  var file = new SourceFile.text(null, source);
+  var file = new SourceFile(source);
 
   var tree = new _Parser(file, source).parse();
 
   analyze([tree], errors: errors, options: options);
 
   if (polyfill) {
     var processCss = new PolyFill(messages, true);
     processCss.process(tree, includes: includes);
   }
 
@@ skipping 11 matching lines @@
 /**
  * Parse the [input] CSS stylesheet into a tree. The [input] can be a [String],
  * or [List<int>] of bytes and returns a [StyleSheet] AST.  The optional
  * [errors] list will contain each error/warning as a [Message].
  */
 StyleSheet parse(input, {List<Message> errors, List<String> options}) {
   var source = _inputAsString(input);
 
   _createMessages(errors: errors, options: options);
 
-  var file = new SourceFile.text(null, source);
+  var file = new SourceFile(source);
   return new _Parser(file, source).parse();
 }
 
 /**
  * Parse the [input] CSS selector into a tree. The [input] can be a [String],
  * or [List<int>] of bytes and returns a [StyleSheet] AST.  The optional
  * [errors] list will contain each error/warning as a [Message].
  */
 // TODO(jmesserly): should rename "parseSelector" and return Selector
 StyleSheet selector(input, {List<Message> errors}) {
   var source = _inputAsString(input);
 
   _createMessages(errors: errors);
 
-  var file = new SourceFile.text(null, source);
+  var file = new SourceFile(source);
   return (new _Parser(file, source)
       ..tokenizer.inSelector = true)
       .parseSelector();
 }
 
 SelectorGroup parseSelectorGroup(input, {List<Message> errors}) {
   var source = _inputAsString(input);
 
   _createMessages(errors: errors);
 
-  var file = new SourceFile.text(null, source);
+  var file = new SourceFile(source);
   return (new _Parser(file, source)
       // TODO(jmesserly): this fix should be applied to the parser. It's tricky
       // because by the time the flag is set one token has already been fetched.
       ..tokenizer.inSelector = true)
       .processSelectorGroup();
 }
 
 String _inputAsString(input) {
   String source;
 
@@ skipping 182 matching lines @@
     var tok = _next();
     var message;
     try {
       message = 'expected $expected, but found $tok';
     } catch (e) {
       message = 'parsing error expected $expected';
     }
     _error(message, tok.span);
   }
 
-  void _error(String message, Span location) {
+  void _error(String message, SourceSpan location) {
     if (location == null) {
       location = _peekToken.span;
     }
     messages.error(message, location);
   }
 
-  void _warning(String message, Span location) {
+  void _warning(String message, SourceSpan location) {
     if (location == null) {
       location = _peekToken.span;
     }
     messages.warning(message, location);
   }
 
-  Span _makeSpan(int start) {
+  SourceSpan _makeSpan(int start) {
     // TODO(terry): there are places where we are creating spans before we eat
     // the tokens, so using _previousToken.end is not always valid.
     var end = _previousToken != null && _previousToken.end >= start
         ? _previousToken.end : _peekToken.end;
     return file.span(start, end);
   }
 
   ///////////////////////////////////////////////////////////////////
   // Top level productions
   ///////////////////////////////////////////////////////////////////
@@ skipping 587 matching lines @@
       if (_maybeEat(TokenKind.COLON)) {
         exprs = processExpr();
       }
 
       return new VarDefinition(definedName, exprs, _makeSpan(start));
     }
 
     return tokId;
   }
 
-  IncludeDirective processInclude(Span span, {bool eatSemiColon: true}) {
+  IncludeDirective processInclude(SourceSpan span, {bool eatSemiColon: true}) {
     /* Stylet grammar:
     *
      *  @include IDENT [(args,...)];
      */
     _next();
 
     var name;
     if (_peekIdentifier()) {
       name = identifier();
     }
@@ skipping 1320 matching lines @@
         expr.expressions[0] = varUsage;
         return expr.expressions;
       }
       break;
     }
 
     return processDimension(t, value, _makeSpan(start));
   }
 
   /** Process all dimension units. */
-  LiteralTerm processDimension(Token t, var value, Span span) {
+  LiteralTerm processDimension(Token t, var value, SourceSpan span) {
     LiteralTerm term;
     var unitType = this._peek();
 
     switch (unitType) {
     case TokenKind.UNIT_EM:
       term = new EmTerm(value, t.text, span);
       _next();    // Skip the unit
       break;
     case TokenKind.UNIT_EX:
       term = new ExTerm(value, t.text, span);
@@ skipping 234 matching lines @@
       return c - 48;
     } else if (c >= 97/*a*/ && c <= 102/*f*/) {
       return c - 87;
     } else if (c >= 65/*A*/ && c <= 70/*F*/) {
       return c - 55;
     } else {
       return -1;
     }
   }
 
-  HexColorTerm _parseHex(String hexText, Span span) {
+  HexColorTerm _parseHex(String hexText, SourceSpan span) {
     var hexValue = 0;
 
      for (var i = 0; i < hexText.length; i++) {
       var digit = _hexDigit(hexText.codeUnitAt(i));
       if (digit < 0) {
         _warning('Bad hex number', span);
         return new HexColorTerm(new BAD_HEX_VALUE(), hexText, span);
       }
       hexValue = (hexValue << 4) + digit;
     }
@@ skipping 143 matching lines @@
 
     if (replace != null && result == null) {
       result = new StringBuffer(text.substring(0, i));
     }
 
     if (result != null) result.write(replace != null ? replace : text[i]);
   }
 
   return result == null ? text : result.toString();
 }