anchor.diff:          operator, operand, scanner.spanFrom(start));
     }
   
  +  /// Returns the unsary operator corresponding to [character], or `null` if
  +  /// the character is not a unary operator.
     UnaryOperator _unaryOperatorFor(int character) {
       switch (character) {
         case $plus:
  
positive.code:     }
    }
  
    NumberExpression _number() {
      var start = scanner.state;
      var first = scanner.peekChar();
  
negative.code:     return new MapExpression(pairs, scanner.spanFrom(start));
    }
  
    /// Consumes an expression that starts with a `#`.
    Expression _hashExpression() {
      assert(scanner.peekChar() == $hash);
      if (scanner.peekChar(1) == $lbrace) return _identifierLike();
  
      var start = scanner.state;
      scanner.expectChar($hash);
  
      var first = scanner.peekChar();
      if (first != null && isDigit(first)) {
        return new ColorExpression(_hexColorContents(), scanner.spanFrom(start));
      }
  
      var afterHash = scanner.state;
      var identifier = _interpolatedIdentifier();
      if (_isHexColor(identifier)) {
        scanner.state = afterHash;
        return new ColorExpression(_hexColorContents(), scanner.spanFrom(start));
      }
  
      var buffer = new InterpolationBuffer();
      buffer.writeCharCode($hash);
      buffer.addInterpolation(identifier);
      return new StringExpression(buffer.interpolation(scanner.spanFrom(start)));
    }
  
    /// Consumes the contents of a hex color, after the `#`.
    SassColor _hexColorContents() {
      var red = _hexDigit();
      var green = _hexDigit();
      var blue = _hexDigit();
  
      var next = scanner.peekChar();
      if (next != null && isHex(next)) {
        red = (red << 4) + green;
        green = (blue << 4) + _hexDigit();
        blue = (_hexDigit() << 4) + _hexDigit();
      } else {
        red = (red << 4) + red;
        green = (green << 4) + green;
        blue = (blue << 4) + blue;
      }
  
      return new SassColor.rgb(red, green, blue);
    }
  
    /// Returns whether [interpolation] is a plain string that can be parsed as a
    /// hex color.
    bool _isHexColor(Interpolation interpolation) {
      var plain = interpolation.asPlain;
      if (plain == null) return false;
      if (plain.length != 3 && plain.length != 6) return false;
      return plain.codeUnits.every(isHex);
    }
  
    // Consumes a single hexadecimal digit.
    int _hexDigit() {
      var char = scanner.peekChar();
      if (char == null || !isHex(char)) scanner.error("Expected hex digit.");
      return asHex(scanner.readChar());
    }
  
    /// Consumes an expression that starts with a `+`.
    Expression _plusExpression() {
      assert(scanner.peekChar() == $plus);
      var next = scanner.peekChar(1);
      return isDigit(next) || next == $dot ? _number() : _unaryOperation();
    }
  
    /// Consumes an expression that starts with a `-`.
    Expression _minusExpression() {
      assert(scanner.peekChar() == $minus);
      var next = scanner.peekChar(1);
  