anchor.diff:        return _objectData.putIfAbsent(key, ifAbsent);
       }
       else {
  -      throw new UnsupportedOperationException("JsonObject is not extendable");  
  -    }
  -  }
  -   
  +      throw new UnsupportedOperationException("JsonObject is not extendable");
  +    }
  +  }
  +
     ///If [isExtendable] is true, or the key already exists,
  -  ///then allow the removal.  
  +  ///then allow the removal.
     ///Throw [UnsupportedOperationException] if we're not allowed to remove a
     ///key
     remove(key) {
  
positive.code:   ///even if the property doesn't yet exist.
    noSuchMethod(String function_name, List args) {
      //print("Called: $function_name with $args");
      
      if (args.length == 0 && function_name.startsWith("get:")) {
        //synthetic getter
        var property = function_name.replaceFirst("get:", "");
  
negative.code: 
  ///JsonObject allows .property name access to JSON by using
  ///noSuchMethod.
  class JsonObject extends Object implements Map {
    var _jsonString;
    Map _objectData;
  
    toString() => _jsonString;
  
    ///[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
    factory JsonObject.fromJsonString(String _jsonString, [JsonObject t]) {
      if (t == null) {
        t = new JsonObject();
      }
      t._jsonString = _jsonString;
      t._objectData = JSON.parse(t._jsonString);
      t._extractElements(t._objectData);
      t.isExtendable = false;
      return t;
  
    }
  
    ///An alternate constructor, allows creating directly from a map
    ///rather than a json string.
    JsonObject.fromMap(Map map) {
      _jsonString = JSON.stringify(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
  