anchor.diff:    return Future.value(result);
   }
   
  -Future<SpriteSheet> _createSpriteSheet(
  -    String imgPath, Map<String, Map<String, Map<String, dynamic>>> assets) {
  +Future<SpriteSheet> _createSpriteSheet(String imgPath, _AssetJson assets) {
     final completer = Completer<SpriteSheet>();
     final img = ImageElement();
     img.onLoad.listen((_) {
       final sprites = <String, Sprite>{};
  -    assets['frames'].forEach((assetName, assetData) {
  +    assets.frames.forEach((assetName, assetData) {
         sprites[assetName] = Sprite(assetData);
       });
       final sheet = SpriteSheet(img, sprites);
  
positive.code:   bool trimmed;
    Rectangle spriteSourceSize;
    Point sourceSize;
    _Asset(Map<String, dynamic> asset)
        : frame = _createRectangle(asset["frame"]),
          trimmed = asset["trimmed"],
          spriteSourceSize = _createRectangle(asset["spriteSourceSize"]),
          sourceSize = _createPoint(asset["sourceSize"]);
  }
  
  Rectangle<int> _createRectangle(Map<String, int> rect) =>
      Rectangle(rect['x'], rect['y'], rect['w'], rect['h']);
  
  Point<int> _createPoint(Map<String, int> rect) => Point(rect['w'], rect['h']);
  
  Future<Map<String, String>> _processAchievementAssets(String assetJson) =>
      Future.value(json.decode(assetJson));
  
negative.code:         String assetJson) =>
      Future.value(json.decode(assetJson));
  
  Future<_AssetJson> _processAssets(String assetJson) =>
      Future.value(_AssetJson.fromJson(json.decode(assetJson)));
  
  class _AssetJson {
    Map<String, _FrameValue> frames;
    _Meta meta;
  
    _AssetJson({
      this.frames,
      this.meta,
    });
  
    factory _AssetJson.fromJson(Map<String, dynamic> json) => new _AssetJson(
          frames: new Map.from(json["frames"]).map((k, v) =>
              new MapEntry<String, _FrameValue>(k, _FrameValue.fromJson(v))),
          meta: _Meta.fromJson(json["meta"]),
        );
  
    Map<String, dynamic> toJson() => {
          "frames": new Map.from(frames)
              .map((k, v) => new MapEntry<String, dynamic>(k, v.toJson())),
          "meta": meta.toJson(),
        };
  }
  
  class _FrameValue {
    _SpriteSourceSizeClass frame;
    bool rotated;
    bool trimmed;
    _SpriteSourceSizeClass spriteSourceSize;
    _Size sourceSize;
  
    _FrameValue({
      this.frame,
      this.rotated,
      this.trimmed,
      this.spriteSourceSize,
      this.sourceSize,
    });
  
    factory _FrameValue.fromJson(Map<String, dynamic> json) => new _FrameValue(
          frame: _SpriteSourceSizeClass.fromJson(json["frame"]),
          rotated: json["rotated"],
          trimmed: json["trimmed"],
          spriteSourceSize:
              _SpriteSourceSizeClass.fromJson(json["spriteSourceSize"]),
          sourceSize: _Size.fromJson(json["sourceSize"]),
        );
  
    Map<String, dynamic> toJson() => {
          "frame": frame.toJson(),
          "rotated": rotated,
          "trimmed": trimmed,
          "spriteSourceSize": spriteSourceSize.toJson(),
          "sourceSize": sourceSize.toJson(),
        };
  }
  
  class _SpriteSourceSizeClass {
    int x;
    int y;
    int w;
    int h;
  
    _SpriteSourceSizeClass({
      this.x,
      this.y,
      this.w,
      this.h,
    });
  
    factory _SpriteSourceSizeClass.fromJson(Map<String, dynamic> json) =>
        new _SpriteSourceSizeClass(
          x: json["x"] ?? 0,
          y: json["y"] ?? 0,
          w: json["w"],
          h: json["h"],
        );
  
    Map<String, dynamic> toJson() => {
          "x": x,
          "y": y,
          "w": w,
          "h": h,
        };
  }
  
  class _Size {
    int w;
    int h;
  
    _Size({
      this.w,
      this.h,
    });
  
    factory _Size.fromJson(Map<String, dynamic> json) => new _Size(
          w: json["w"],
          h: json["h"],
        );
  
    Map<String, dynamic> toJson() => {
          "w": w,
          "h": h,
        };
  }
  
  class _Meta {
    String app;
    String version;
    String image;
    String format;
    _Size size;
    String scale;
    String smartupdate;
  
    _Meta({
      this.app,
      this.version,
      this.image,
      this.format,
      this.size,
      this.scale,
      this.smartupdate,
    });
  
    factory _Meta.fromJson(Map<String, dynamic> json) => new _Meta(
          app: json["app"],
          version: json["version"],
          image: json["image"],
          format: json["format"],
          size: _Size.fromJson(json["size"]),
          scale: json["scale"],
          smartupdate: json["smartupdate"],
        );
  
    Map<String, dynamic> toJson() => {
          "app": app,
          "version": version,
          "image": image,
          "format": format,
          "size": size.toJson(),
          "scale": scale,
          "smartupdate": smartupdate,
        };
  }
  