anchor.diff:     * string is partial matching
      * {column: condition}
      */
  -  set keyword(Map m){
  -    if(m==null) return;
  -    _filter =m;
  -    _viewList=_foldHelper();
  -  }
  -  void setKeyword(String key, Object val){
  +  set keyword(Map m) {
  +    if (m == null) return;
  +    _filter = m;
  +    _viewList = _foldHelper();
  +  }
  +
  +  void setKeyword(String key, Object val) {
       //_viewList=[];
  -    if(val is String && val.length==0){
  +    if (val is String && val.length == 0) {
         _filter.remove(key);
  -    }else
  -    {
  -      _filter[key]=val;
  +    } else {
  +      _filter[key] = val;
       }
  -    _viewList=_foldHelper();
  -  }
  +    _viewList = _foldHelper();
  +  }
  +
     /**
      * when src is changed, regenerate view
      */
  -  void invalidate(){
  -    _viewList=_foldHelper();
  -  }
  -
  -  void removeKeyword(String key){
  +  void invalidate() {
  +    _viewList = _foldHelper();
  +  }
  +
  +  void removeKeyword(String key) {
       _filter.remove(key);
     }
  -  _foldHelper(){
  -    return new UnmodifiableListView(_srcList.fold([], (List init,val){
  -                var test = _filter.keys.every((k){
  -                  if(val[k] is String){
  -                    return val[k].contains(_filter[k]) ;
  -                  }else if(val[k] is bool){
  -                    return val[k] == _filter[k];
  -                  }else{
  -                    try{
  -                      var _num=num.parse(_filter[k]);
  -                      return  val[k] == _num;
  -                    }catch(e){
  -                      return false;
  -                    }
  -                  }
  -                  });
  -                if(test) init.add(val);
  -                return init;
  -        }));
  -  }
  -
  -  operator [](index) => _filter.length==0 ? _srcList[index] : _viewList[index];
  -  operator []=(index,value) => _srcList.add(value);
  +
  +  _foldHelper() {
  +    return new UnmodifiableListView(_srcList.fold([], (List init, val) {
  +      var test = _filter.keys.every((k) {
  +        if (val[k] is String) {
  +          return val[k].contains(_filter[k]);
  +        } else if (val[k] is bool) {
  +          return val[k] == _filter[k];
  +        } else {
  +          try {
  +            var _num = num.parse(_filter[k]);
  +            return val[k] == _num;
  +          } catch (e) {
  +            return false;
  +          }
  +        }
  +      });
  +      if (test) init.add(val);
  +      return init;
  +    }));
  +  }
  +
  +  operator [](index) => _filter.length == 0 ? _srcList[index] : _viewList[index];
  +  operator []=(index, value) => _srcList.add(value);
     //for grid internal mask
  -  get length => _filter.length==0 ? _srcList.length : _viewList.length;
  -  set length(val){_srcList.length=val;}
  -  add(val){
  +  get length => _filter.length == 0 ? _srcList.length : _viewList.length;
  +  set length(val) {
  +    _srcList.length = val;
  +  }
  +
  +  add(val) {
       _srcList.add(val);
     }
  -  addAll(val){
  +
  +  addAll(val) {
       _srcList.addAll(val);
     }
  -  clear(){
  +
  +  clear() {
       _srcList.clear();
  -    _viewList=new UnmodifiableListView([]);
  -  }
  -  bool remove(Object element){
  +    _viewList = new UnmodifiableListView([]);
  +  }
  +
  +  bool remove(Object element) {
       return _srcList.remove(element);
     }
  +
     void sort([int compare(a, b)]) {
       _srcList.sort(compare);
  -    if(_viewList!=null && _viewList.length>0)
  -      _viewList=_foldHelper();
  +    if (_viewList != null && _viewList.length > 0) _viewList = _foldHelper();
     }
   
     Iterable get reversed => _srcList.reversed;
  
positive.code: library slick.util;
  import 'dart:html';
  import 'dart:math';
  import 'dart:collection';
  import 'package:logging/logging.dart';
  import 'slick_core.dart' as core;
  import 'dart:convert';
  Logger _log = new Logger('slick.util');
  
  
  
  
  /** TODO add scope
   * find element's cloest parent of target css selector rule
  
negative.code:    * [collapsedField] field describe collapsed(true) or expand(false)
     * [items] List of row
     */
    factory HierarchFilterList.withKeyField(
        [String parentField = '_parent', String idField = 'id', String collapsedField = '_collapsed', List items]) {
      HierarchFilterList hier = new HierarchFilterList._(items);
      hier._parentField = parentField;
      hier._idField = idField;
      hier._collapsedField = collapsedField;
      return hier;
    }
  
    _foldHelper() {
      Map tMap = {'parents': new Set(), 'list': []};
      return new UnmodifiableListView(_srcList.fold(tMap, (Map init, val) {
        //_filter.keys.every(test)
        bool showRow = _filter.keys.every((k) {
          if (k == _collapsedField) {
            //filter by tree hierarchical
            if (init['parents'].contains(val[_parentField])) {
              init['parents'].add(val[_idField]);
              return false;
            } else if (val[k] == true) {
              init['parents'].add(val[_idField]);
              return true;
            } else {
              return true;
            }
          } else if (_filter[k] is Function) {
            bool isShow = _filter[k](val[k]);
            if (!isShow) init['parents'].add(val[_idField]);
            return isShow;
          } else {
            return true;
          }
        });
        if (showRow) init['list'].add(val);
        return init;
      })['list']);
    }
  }
  
  /**
   * meta data interface for data
   * Meta data is a list wrappper that provide getMetaData when need override style in row rendering
   */
  abstract class IMetaData {
    Map getMetaData(int rowId);
    void setMetaData(Function metaFunc);
  }
  
  class MetaList<T> extends ListBase<T> with IMetaData {
    Function _func;
    List<T> innerList;
    MetaList(this.innerList, [this._func]) {}
  
    Map getMetaData(int rowId) {
      return _func(rowId);
    }
  
    void setMetaData(_) => _func = _;
  
    int get length => innerList.length;
  
    void set length(int length) {
      innerList.length = length;
    }
  
    void operator []=(int index, T value) {
      innerList[index] = value;
    }
  
    T operator [](int index) => innerList[index];
  
    // Though not strictly necessary, for performance reasons
  