anchor.diff:        this[property] = args[0];
         return this[property];
       }
  -    
  +
       //if we get here, then we've not found it - throw.
       super.noSuchMethod(function_name, args);
     }
  -  
  +
     ///Private:
     ///If the [data] object passed in is a MAP, then we iterate through each of
  -  ///the values of the map, and if any value is a map, then we create a new 
  +  ///the values of the map, and if any value is a map, then we create a new
     ///[JsonObject] replacing that map in the original data with that [JsonObject]
     ///to a new [JsonObject].  If the value is a Collection, then we call this
     ///function recursively.
     ///
  -  ///If the [data] object passed in is a Collection, then we iterate through 
  +  ///If the [data] object passed in is a Collection, then we iterate through
     ///each item.  If that item is a map, then we replace the item with a
  -  ///[JsonObject] created from the map.  If the item is a Collection, then we 
  +  ///[JsonObject] created from the map.  If the item is a Collection, then we
     ///call this function recursively.
     _extractElements(data) {
       if (data is Map) {
         //iterate through each of the k,v pairs, replacing maps with jsonObjects
         data.forEach((key,value) {
  -        
  +
           if (value is Map) {
             //replace the existing Map with a JsonObject
             data[key] = new JsonObject.fromMap(value);
  
positive.code: 
  ///JsonObject allows .property name access to JSON by using
  ///noSuchMethod.
  class JsonObject extends Object implements Map { 
    var _jsonString;
    Map _objectData;
    
    ///[isExtendable] decides if a new item can be added to the internal 
    ///map via the noSuchMethod property, or the functions inherited from the 
    ///map interface.   
    ///
    ///If set to false, then only the properties that were 
    ///in the original map or json string passed in can be used.
    ///
    ///If set to true, then calling o.blah="123" will create a new blah property
    ///if it didn't already exist.
    ///
    ///Setting this to false can help with checking for typos, and is false by 
    ///default when a JsonObject is created with [JsonObject.fromJsonString()] 
    ///or [JsonObject.fromMap()].
    ///The default constructor [JsonObject()], however will set this value to 
    ///true, otherwise you can't actually add any new properties.
    bool isExtendable;
    
    //default constructor.
    //creates a new empty map.
    JsonObject() {
      _objectData = new Map();
      isExtendable = true;
    }
    
    /// eager constructor parses the jsonString using
    /// JSON.parse(), and
    /// replaces all maps recursively with JsonObjects 
    JsonObject.fromJsonString(this._jsonString) {
      _objectData = JSON.parse(_jsonString);   
      
      _extractElements(_objectData);
      isExtendable = false;
    }
    
    ///An alternate constructor, allows creating directly from a map 
    ///rather than a json string.
    JsonObject.fromMap(Map map) {
      _objectData = map;
      _extractElements(_objectData);
      isExtendable = false;
    }
    
    
    ///noSuchMethod() is where the magic happens.
    ///If we try to access a property using dot notation (eg: o.wibble ), then
    ///noSuchMethod will be invoked, and identify the getter or setter name.
    ///It then looks up in the map contained in _objectData (represented using 
    ///this (as this class implements [Map], and forwards it's calls to that
    ///class.
    ///If it finds the getter or setter then it either updates the value, or
  
negative.code:       _objectData.clear();
      }
      else {
        throw new UnsupportedOperationException("JsonObject is not extendable");
      }
  
    }
  
  }
  
  
  