text: /**
   * Bunch of useful filters for angularJS(with no external dependencies!)
   * @version v0.5.7 - 2015-10-04 * @link https://github.com/a8m/angular-filter
   * @author Ariel Mashraki <ariel@mashraki.co.il>
   * @license MIT License, http://www.opensource.org/licenses/MIT
   */
  (function ( window, angular, undefined ) {
  /*jshint globalstrict:true*/
  'use strict';
  
  var isDefined = angular.isDefined,
      isUndefined = angular.isUndefined,
      isFunction = angular.isFunction,
      isString = angular.isString,
      isNumber = angular.isNumber,
      isObject = angular.isObject,
      isArray = angular.isArray,
      forEach = angular.forEach,
      extend = angular.extend,
      copy = angular.copy,
      equals = angular.equals;
  
  
  /**
   * @description
   * get an object and return array of values
   * @param object
   * @returns {Array}
   */
  function toArray(object) {
    return isArray(object) 
      ? object 
      : Object.keys(object).map(function(key) {
        return object[key];
      });
  }
  
  /**
   * @param value
   * @returns {boolean}
   */
  function isNull(value) {
      return value === null;
  }
  
  /**
   * @description
   * return if object contains partial object
   * @param partial{object}
   * @param object{object}
   * @returns {boolean}
   */
  function objectContains(partial, object) {
    var keys = Object.keys(partial);
  
    return keys.map(function(el) {
      return (object[el] !== undefined) && (object[el] == partial[el]);
    }).indexOf(false) == -1;
  
  }
  
  /**
   * @description
   * search for approximate pattern in string
   * @param word
   * @param pattern
   * @returns {*}
   */
  function hasApproxPattern(word, pattern) {
    if(pattern === '')
      return word;
  
    var index = word.indexOf(pattern.charAt(0));
  
    if(index === -1)
      return false;
  
    return hasApproxPattern(word.substr(index+1), pattern.substr(1))
  }
  
  /**
   * @description
   * return the first n element of an array,
   * if expression provided, is returns as long the expression return truthy
   * @param array
   * @param n {number}
   * @param expression {$parse}
   * @return array or single object
   */
  function getFirstMatches(array, n, expression) {
    var count = 0;
  
    return array.filter(function(elm) {
      var rest = isDefined(expression) ? (count < n && expression(elm)) : count < n;
      count = rest ? count+1 : count;
  
      return rest;
    });
  }
  /**
   * Polyfill to ECMA6 String.prototype.contains
   */
  if (!String.prototype.contains) {
    String.prototype.contains = function() {
      return String.prototype.indexOf.apply(this, arguments) !== -1;
    };
  }
  
  /**
   * @param num {Number}
   * @param decimal {Number}
   * @param $math
   * @returns {Number}
   */
  function convertToDecimal(num, decimal, $math){
    return $math.round(num * $math.pow(10,decimal)) / ($math.pow(10,decimal));
  }
  
  /**
   * @description
   * Get an object, and return an array composed of it's properties names(nested too).
   * @param obj {Object}
   * @param stack {Array}
   * @param parent {String}
   * @returns {Array}
   * @example
   * parseKeys({ a:1, b: { c:2, d: { e: 3 } } }) ==> ["a", "b.c", "b.d.e"]
   */
  function deepKeys(obj, stack, parent) {
    stack = stack || [];
    var keys = Object.keys(obj);
  
    keys.forEach(function(el) {
      //if it's a nested object
      if(isObject(obj[el]) && !isArray(obj[el])) {
        //concatenate the new parent if exist
        var p = parent ? parent + '.' + el : parent;
        deepKeys(obj[el], stack, p || el);
      } else {
        //create and save the key
        var key = parent ? parent + '.' + el : el;
        stack.push(key)
      }
    });
    return stack
  }
  
  /**
   * @description
   * Test if given object is a Scope instance
   * @param obj
   * @returns {Boolean}
   */
  function isScope(obj) {
    return obj && obj.$evalAsync && obj.$watch;
  }
  
  /**
   * @ngdoc filter
   * @name a8m.angular
   * @kind function
   *
   * @description
   * reference to angular function
   */
  
  angular.module('a8m.angular', [])
  
      .filter('isUndefined', function () {
        return function (input) {
          return angular.isUndefined(input);
        }
      })
      .filter('isDefined', function() {
        return function (input) {
          return angular.isDefined(input);
        }
      })
      .filter('isFunction', function() {
        return function (input) {
          return angular.isFunction(input);
        }
      })
      .filter('isString', function() {
        return function (input) {
          return angular.isString(input)
        }
      })
      .filter('isNumber', function() {
        return function (input) {
          return angular.isNumber(input);
        }
      })
      .filter('isArray', function() {
        return function (input) {
          return angular.isArray(input);
        }
      })
      .filter('isObject', function() {
        return function (input) {
          return angular.isObject(input);
        }
      })
      .filter('isEqual', function() {
        return function (o1, o2) {
          return angular.equals(o1, o2);
        }
      });
  
  /**
   * @ngdoc filter
   * @name a8m.conditions
   * @kind function
   *
   * @description
   * reference to math conditions
   */
   angular.module('a8m.conditions', [])
  
    .filter({
      isGreaterThan  : isGreaterThanFilter,
      '>'            : isGreaterThanFilter,
  
      isGreaterThanOrEqualTo  : isGreaterThanOrEqualToFilter,
      '>='                    : isGreaterThanOrEqualToFilter,
  
      isLessThan  : isLessThanFilter,
      '<'         : isLessThanFilter,
  
      isLessThanOrEqualTo  : isLessThanOrEqualToFilter,
      '<='                 : isLessThanOrEqualToFilter,
  
      isEqualTo  : isEqualToFilter,
      '=='       : isEqualToFilter,
  
      isNotEqualTo  : isNotEqualToFilter,
      '!='          : isNotEqualToFilter,
  
      isIdenticalTo  : isIdenticalToFilter,
      '==='          : isIdenticalToFilter,
  
      isNotIdenticalTo  : isNotIdenticalToFilter,
      '!=='             : isNotIdenticalToFilter
    });
  
    function isGreaterThanFilter() {
      return function (input, check) {
        return input > check;
      };
    }
  
    function isGreaterThanOrEqualToFilter() {
      return function (input, check) {
        return input >= check;
      };
    }
  
    function isLessThanFilter() {
      return function (input, check) {
        return input < check;
      };
    }
  
    function isLessThanOrEqualToFilter() {
      return function (input, check) {
        return input <= check;
      };
    }
  
    function isEqualToFilter() {
      return function (input, check) {
        return input == check;
      };
    }
  
    function isNotEqualToFilter() {
      return function (input, check) {
        return input != check;
      };
    }
  
    function isIdenticalToFilter() {
      return function (input, check) {
        return input === check;
      };
    }
  
    function isNotIdenticalToFilter() {
      return function (input, check) {
        return input !== check;
      };
    }
  /**
   * @ngdoc filter
   * @name isNull
   * @kind function
   *
   * @description
   * checks if value is null or not
   * @return Boolean
   */
  angular.module('a8m.is-null', [])
      .filter('isNull', function () {
        return function(input) {
          return isNull(input);
        }
      });
  
  /**
   * @ngdoc filter
   * @name after-where
   * @kind function
   *
   * @description
   * get a collection and properties object, and returns all of the items
   * in the collection after the first that found with the given properties.
   *
   */
  angular.module('a8m.after-where', [])
      .filter('afterWhere', function() {
        return function (collection, object) {
  
          collection = isObject(collection)
            ? toArray(collection)
            : collection;
  
          if(!isArray(collection) || isUndefined(object)) return collection;
  
          var index = collection.map( function( elm ) {
            return objectContains(object, elm);
          }).indexOf( true );
  
          return collection.slice((index === -1) ? 0 : index);
        }
      });
  
  /**
   * @ngdoc filter
   * @name after
   * @kind function
   *
   * @description
   * get a collection and specified count, and returns all of the items
   * in the collection after the specified count.
   *
   */
  
  angular.module('a8m.after', [])
      .filter('after', function() {
        return function (collection, count) {
          collection = isObject(collection)
            ? toArray(collection)
            : collection;
  
          return (isArray(collection))
            ? collection.slice(count)
            : collection;
        }
      });
  
  /**
   * @ngdoc filter
   * @name before-where
   * @kind function
   *
   * @description
   * get a collection and properties object, and returns all of the items
   * in the collection before the first that found with the given properties.
   */
  angular.module('a8m.before-where', [])
    .filter('beforeWhere', function() {
      return function (collection, object) {
  
        collection = isObject(collection)
          ? toArray(collection)
          : collection;
  
        if(!isArray(collection) || isUndefined(object)) return collection;
  
        var index = collection.map( function( elm ) {
          return objectContains(object, elm);
        }).indexOf( true );
  
        return collection.slice(0, (index === -1) ? collection.length : ++index);
      }
    });
  
  /**
   * @ngdoc filter
   * @name before
   * @kind function
   *
   * @description
   * get a collection and specified count, and returns all of the items
   * in the collection before the specified count.
   */
  angular.module('a8m.before', [])
      .filter('before', function() {
        return function (collection, count) {
          collection = isObject(collection)
            ? toArray(collection)
            : collection;
  
          return (isArray(collection))
            ? collection.slice(0, (!count) ? count : --count)
            : collection;
        }
      });
  
  /**
   * @ngdoc filter
   * @name chunkBy
   * @kind function
   *
   * @description
   * Collect data into fixed-length chunks or blocks
   */
  
  angular.module('a8m.chunk-by', ['a8m.filter-watcher'])
      .filter('chunkBy', ['filterWatcher', function (filterWatcher) {
        return function (array, n, fillVal) {
  
          return filterWatcher.isMemoized('chunkBy', arguments) ||
              filterWatcher.memoize('chunkBy', arguments, this,
                  _chunkBy(array, n, fillVal));
          /**
           * @description
           * Get array with size `n` in `val` inside it.
           * @param n
           * @param val
           * @returns {Array}
           */
          function fill(n, val) {
            var ret = [];
            while (n--) ret[n] = val;
            return ret;
          }
  
          function _chunkBy(array, n, fillVal) {
            if (!isArray(array)) return array;
            return array.map(function (el, i, self) {
              i = i * n;
              el = self.slice(i, i + n);
              return !isUndefined(fillVal) && el.length < n
                  ? el.concat(fill(n - el.length, fillVal))
                  : el;
            }).slice(0, Math.ceil(array.length / n));
          }
        }
      }]);
  
  /**
   * @ngdoc filter
   * @name concat
   * @kind function
   *
   * @description
   * get (array/object, object/array) and return merged collection
   */
  angular.module('a8m.concat', [])
    .filter('concat', [function () {
      return function (collection, joined) {
  
        if (isUndefined(joined)) return collection;
  
        if (isArray(collection)) {
          return isObject(joined)
            ? collection.concat(toArray(joined))
            : collection.concat(joined);
        }
  
        if (isObject(collection)) {
          var array = toArray(collection);
          return (isObject(joined))
            ? array.concat(toArray(joined))
            : array.concat(joined);
        }
        return collection;
      };
    }
  ]);
  
  /**
   * @ngdoc filter
   * @name contains
   * @kind function
   *
   * @description
   * Checks if given expression is present in one or more object in the collection
   */
  angular.module('a8m.contains', [])
    .filter({
      contains: ['$parse', containsFilter],
      some: ['$parse', containsFilter]
    });
  
  function containsFilter($parse) {
      return function (collection, expression) {
  
        collection = isObject(collection) ? toArray(collection) : collection;
  
        if(!isArray(collection) || isUndefined(expression)) {
          return false;
        }
  
        return collection.some(function(elm) {
          return (isObject(elm) || isFunction(expression))
            ? $parse(expression)(elm)
            : elm === expression;
        });
  
      }
   }
  
  /**
   * @ngdoc filter
   * @name countBy
   * @kind function
   *
   * @description
   * Sorts a list into groups and returns a count for the number of objects in each group.
   */
  
  angular.module('a8m.count-by', [])
  
    .filter('countBy', [ '$parse', function ( $parse ) {
      return function (collection, property) {
  
        var result = {},
          get = $parse(property),
          prop;
  
        collection = (isObject(collection)) ? toArray(collection) : collection;
  
        if(!isArray(collection) || isUndefined(property)) {
          return collection;
        }
  
        collection.forEach( function( elm ) {
          prop = get(elm);
  
          if(!result[prop]) {
            result[prop] = 0;
          }
  
          result[prop]++;
        });
  
        return result;
      }
    }]);
  
  /**
   * @ngdoc filter
   * @name defaults
   * @kind function
   *
   * @description
   * defaultsFilter allows to specify a default fallback value for properties that resolve to undefined.
   */
  angular.module('a8m.defaults', [])
    .filter('defaults', ['$parse', function( $parse ) {
      return function(collection, defaults) {
  
        collection = isObject(collection) ? toArray(collection) : collection;
  
        if(!isArray(collection) || !isObject(defaults)) {
          return collection;
        }
  
        var keys = deepKeys(defaults);
  
        collection.forEach(function(elm) {
          //loop through all the keys
          keys.forEach(function(key) {
            var getter = $parse(key);
            var setter = getter.assign;
            //if it's not exist
            if(isUndefined(getter(elm))) {
              //get from defaults, and set to the returned object
              setter(elm, getter(defaults))
            }
          });
        });
  
        return collection;
      }
    }]);
  /**
   * @ngdoc filter
   * @name every
   * @kind function
   *
   * @description
   * Checks if given expression is present in all members in the collection
   *
   */
  angular.module('a8m.every', [])
    .filter('every', ['$parse', function($parse) {
      return function (collection, expression) {
        collection = isObject(collection) ? toArray(collection) : collection;
  
        if(!isArray(collection) || isUndefined(expression)) {
          return true;
        }
  
        return collection.every( function(elm) {
          return (isObject(elm) || isFunction(expression))
            ? $parse(expression)(elm)
            : elm === expression;
        });
      }
    }]);
  
  /**
   * @ngdoc filter
   * @name filterBy
   * @kind function
   *
   * @description
   * filter by specific properties, avoid the rest
   */
  angular.module('a8m.filter-by', [])
    .filter('filterBy', ['$parse', function( $parse ) {
      return function(collection, properties, search) {
        var comparator;
  
        search = (isString(search) || isNumber(search)) ?
          String(search).toLowerCase() : undefined;
  
        collection = isObject(collection) ? toArray(collection) : collection;
  
        if(!isArray(collection) || isUndefined(search)) {
          return collection;
        }
  
        return collection.filter(function(elm) {
          return properties.some(function(prop) {
  
            /**
             * check if there is concatenate properties
             * example:
             * object: { first: 'foo', last:'bar' }
             * filterBy: ['first + last'] => search by full name(i.e 'foo bar')
             */
            if(!~prop.indexOf('+')) {
              comparator = $parse(prop)(elm)
            } else {
              var propList = prop.replace(new RegExp('\\s', 'g'), '').split('+');
              comparator = propList.reduce(function(prev, cur, index) {
                return (index === 1) ? $parse(prev)(elm) + ' ' + $parse(cur)(elm) :
                  prev + ' ' + $parse(cur)(elm);
              });
            }
  
            return (isString(comparator) || isNumber(comparator))
              ? String(comparator).toLowerCase().contains(search)
              : false;
          });
        });
      }
    }]);
  
  /**
   * @ngdoc filter
   * @name first
   * @kind function
   *
   * @description
   * Gets the first element or first n elements of an array
   * if callback is provided, is returns as long the callback return truthy
   */
  angular.module('a8m.first', [])
    .filter('first', ['$parse', function( $parse ) {
      return function(collection) {
        var n
          , getter
          , args;
  
        collection = isObject(collection)
          ? toArray(collection)
          : collection;
  
        if(!isArray(collection)) {
          return collection;
        }
  
        args = Array.prototype.slice.call(arguments, 1);
        n = (isNumber(args[0])) ? args[0] : 1;
        getter = (!isNumber(args[0]))  ? args[0] : (!isNumber(args[1])) ? args[1] : undefined;
  
        return (args.length) ? getFirstMatches(collection, n,(getter) ? $parse(getter) : getter) :
          collection[0];
      }
    }]);
  
  /**
   * @ngdoc filter
   * @name flatten
   * @kind function
   *
   * @description
   * Flattens a nested array (the nesting can be to any depth).
   * If you pass shallow, the array will only be flattened a single level
   */
  angular.module('a8m.flatten', [])
    .filter('flatten', function () {
      return function(collection, shallow) {
  
        shallow = shallow || false;
        collection = isObject(collection)
          ? toArray(collection)
          : collection;
  
        if(!isArray(collection)) {
          return collection;
        }
  
        return !shallow
          ? flatten(collection, 0)
          : [].concat.apply([], collection);
      }
    });
  
  /**
   * flatten nested array (the nesting can be to any depth).
   * @param array {Array}
   * @param i {int}
   * @returns {Array}
   * @private
   */
  function flatten(array, i) {
    i = i || 0;
  
    if(i >= array.length)
      return array;
  
    if(isArray(array[i])) {
      return flatten(array.slice(0,i)
        .concat(array[i], array.slice(i+1)), i);
    }
    return flatten(array, i+1);
  }
  
  /**
   * @ngdoc filter
   * @name fuzzyByKey
   * @kind function
   *
   * @description
   * fuzzy string searching by key
   */
  angular.module('a8m.fuzzy-by', [])
    .filter('fuzzyBy', ['$parse', function ( $parse ) {
      return function (collection, property, search, csensitive) {
  
        var sensitive = csensitive || false,
          prop, getter;
  
        collection = isObject(collection) ? toArray(collection) : collection;
  
        if(!isArray(collection) || isUndefined(property)
          || isUndefined(search)) {
          return collection;
        }
  
        getter = $parse(property);
  
        return collection.filter(function(elm) {
  
          prop = getter(elm);
          if(!isString(prop)) {
            return false;
          }
  
          prop = (sensitive) ? prop : prop.toLowerCase();
          search = (sensitive) ? search : search.toLowerCase();
  
          return hasApproxPattern(prop, search) !== false
        })
      }
  
   }]);
  /**
   * @ngdoc filter
   * @name fuzzy
   * @kind function
   *
   * @description
   * fuzzy string searching for array of strings, objects
   */
  angular.module('a8m.fuzzy', [])
    .filter('fuzzy', function () {
      return function (collection, search, csensitive) {
        var sensitive = csensitive || false;
        collection = isObject(collection) ? toArray(collection) : collection;
  
        if(!isArray(collection) || isUndefined(search)) {
          return collection;
        }
  
        search = (sensitive) ? search : search.toLowerCase();
  
        return collection.filter(function(elm) {
          if(isString(elm)) {
            elm = (sensitive) ? elm : elm.toLowerCase();
            return hasApproxPattern(elm, search) !== false
          }
          return (isObject(elm)) ? _hasApproximateKey(elm, search) : false;
        });
  
        /**
         * checks if object has key{string} that match
         * to fuzzy search pattern
         * @param object
         * @param search
         * @returns {boolean}
         * @private
         */
        function _hasApproximateKey(object, search) {
          var properties = Object.keys(object),
            prop, flag;
          return 0 < properties.filter(function (elm) {
            prop = object[elm];
  
            //avoid iteration if we found some key that equal[performance]
            if(flag) return true;
  
            if (isString(prop)) {
              prop = (sensitive) ? prop : prop.toLowerCase();
              return flag = (hasApproxPattern(prop, search) !== false);
            }
  
            return false;
  
          }).length;
        }
      }
    });
  
  /**
   * @ngdoc filter
   * @name groupBy
   * @kind function
   *
   * @description
   * Create an object composed of keys generated from the result of running each element of a collection,
   * each key is an array of the elements.
   */
  
  angular.module('a8m.group-by', [ 'a8m.filter-watcher' ])
    .filter('groupBy', [ '$parse', 'filterWatcher', function ( $parse, filterWatcher ) {
      return function (collection, property) {
  
        if(!isObject(collection) || isUndefined(property)) {
          return collection;
        }
  
        return filterWatcher.isMemoized('groupBy', arguments) ||
          filterWatcher.memoize('groupBy', arguments, this,
            _groupBy(collection, $parse(property)));
  
        /**
         * groupBy function
         * @param collection
         * @param getter
         * @returns {{}}
         */
        function _groupBy(collection, getter) {
          var result = {};
          var prop;
  
          forEach( collection, function( elm ) {
            prop = getter(elm);
  
            if(!result[prop]) {
              result[prop] = [];
            }
            result[prop].push(elm);
          });
          return result;
        }
      }
   }]);
  
  /**
   * @ngdoc filter
   * @name isEmpty
   * @kind function
   *
   * @description
   * get collection or string and return if it empty
   */
  angular.module('a8m.is-empty', [])
    .filter('isEmpty', function () {
      return function(collection) {
        return isObject(collection)
          ? !toArray(collection).length
          : !collection.length;
      }
    });
  
  /**
   * @ngdoc filter
   * @name join
   * @kind function
   *
   * @description
   * join a collection by a provided delimiter (space by default)
   */
  angular.module('a8m.join', [])
    .filter('join', function () {
      return function (input, delimiter) {
        if (isUndefined(input) || !isArray(input)) {
          return input;
        }
        if (isUndefined(delimiter)) delimiter = ' ';
  
        return input.join(delimiter);
      };
    })
  ;
  
  /**
   * @ngdoc filter
   * @name last
   * @kind function
   *
   * @description
   * Gets the last element or last n elements of an array
   * if callback is provided, is returns as long the callback return truthy
   */
  angular.module('a8m.last', [])
    .filter('last', ['$parse', function( $parse ) {
      return function(collection) {
        var n
          , getter
          , args
          //cuz reverse change our src collection
          //and we don't want side effects
          , reversed = copy(collection);
  
        reversed = isObject(reversed)
          ? toArray(reversed)
          : reversed;
  
        if(!isArray(reversed)) {
          return reversed;
        }
  
        args = Array.prototype.slice.call(arguments, 1);
        n = (isNumber(args[0])) ? args[0] : 1;
        getter = (!isNumber(args[0]))  ? args[0] : (!isNumber(args[1])) ? args[1] : undefined;
  
        return (args.length)
          //send reversed collection as arguments, and reverse it back as result
          ? getFirstMatches(reversed.reverse(), n,(getter) ? $parse(getter) : getter).reverse()
          //get the last element
          : reversed[reversed.length-1];
      }
    }]);
  
  /**
   * @ngdoc filter
   * @name map
   * @kind function
   *
   * @description
   * Returns a new collection of the results of each expression execution.
   */
  angular.module('a8m.map', [])
    .filter('map', ['$parse', function($parse) {
      return function (collection, expression) {
  
        collection = isObject(collection)
          ? toArray(collection)
          : collection;
  
        if(!isArray(collection) || isUndefined(expression)) {
          return collection;
        }
  
        return collection.map(function (elm) {
          return $parse(expression)(elm);
        });
      }
    }]);
  
  /**
   * @ngdoc filter
   * @name omit
   * @kind function
   *
   * @description
   * filter collection by expression
   */
  
  angular.module('a8m.omit', [])
  
    .filter('omit', ['$parse', function($parse) {
      return function (collection, expression) {
  
        collection = isObject(collection)
          ? toArray(collection)
          : collection;
  
        if(!isArray(collection) || isUndefined(expression)) {
          return collection;
        }
  
        return collection.filter(function (elm) {
          return !($parse(expression)(elm));
        });
      }
    }]);
  
  /**
   * @ngdoc filter
   * @name pick
   * @kind function
   *
   * @description
   * filter collection by expression
   */
  
  angular.module('a8m.pick', [])
  
    .filter('pick', ['$parse', function($parse) {
      return function (collection, expression) {
  
        collection = isObject(collection)
          ? toArray(collection)
          : collection;
  
        if(!isArray(collection) || isUndefined(expression)) {
          return collection;
        }
  
        return collection.filter(function (elm) {
          return $parse(expression)(elm);
        });
      }
    }]);
  
  /**
   * @ngdoc filter
   * @name range
   * @kind function
   *
   * @description
   * rangeFilter provides some support for a for loop using numbers
   */
  angular.module('a8m.range', [])
    .filter('range', function () {
      return function (input, total) {
        for (var i = 0; i < parseInt(total); i++) {
          input.push(i);
        }
        return input;
  	  };
    });
  /**
   * @ngdoc filter
   * @name removeWith
   * @kind function
   *
   * @description
   * get collection and properties object, and removed elements
   * with this properties
   */
  
  angular.module('a8m.remove-with', [])
    .filter('removeWith', function() {
      return function (collection, object) {
  
        if(isUndefined(object)) {
          return collection;
        }
        collection = isObject(collection)
          ? toArray(collection)
          : collection;
  
        return collection.filter(function (elm) {
          return !objectContains(object, elm);
        });
      }
    });
  
  
  /**
   * @ngdoc filter
   * @name remove
   * @kind function
   *
   * @description
   * remove specific members from collection
   */
  
  angular.module('a8m.remove', [])
  
    .filter('remove', function () {
      return function (collection) {
        collection = isObject(collection) ? toArray(collection) : collection;
        var args = Array.prototype.slice.call(arguments, 1);
  
        if(!isArray(collection)) {
          return collection;
        }
  
        return collection.filter( function( member ) {
          return !args.some(function(nest) {
            return equals(nest, member);
          })
        });
      }
    });
  
  /**
   * @ngdoc filter
   * @name reverse
   * @kind function
   *
   * @description
   * Reverses a string or collection
   */
  angular.module('a8m.reverse', [])
      .filter('reverse',[ function () {
        return function (input) {
          input = isObject(input) ? toArray(input) : input;
  
          if(isString(input)) {
            return input.split('').reverse().join('');
          }
  
          return isArray(input)
            ? input.slice().reverse()
            : input;
        }
      }]);
  
  /**
   * @ngdoc filter
   * @name searchField
   * @kind function
   *
   * @description
   * for each member, join several strings field and add them to
   * new field called 'searchField' (use for search filtering)
   */
  angular.module('a8m.search-field', [])
    .filter('searchField', ['$parse', function ($parse) {
      return function (collection) {
  
        var get, field;
  
        collection = isObject(collection) ? toArray(collection) : collection;
  
        var args = Array.prototype.slice.call(arguments, 1);
  
        if(!isArray(collection) || !args.length) {
          return collection;
        }
  
        return collection.map(function(member) {
  
          field = args.map(function(field) {
            get = $parse(field);
            return get(member);
          }).join(' ');
  
          return extend(member, { searchField: field });
        });
      }
    }]);
  
  /**
   * @ngdoc filter
   * @name toArray
   * @kind function
   *
   * @description
   * Convert objects into stable arrays.
   * if addKey set to true,the filter also attaches a new property
   * $key to the value containing the original key that was used in
   * the object we are iterating over to reference the property
   */
  angular.module('a8m.to-array', [])
    .filter('toArray', function() {
      return function (collection, addKey) {
  
        if(!isObject(collection)) {
          return collection;
        }
  
        return !addKey
          ? toArray(collection)
          : Object.keys(collection).map(function (key) {
              return extend(collection[key], { $key: key });
            });
      }
    });
  
  /**
   * @ngdoc filter
   * @name unique/uniq
   * @kind function
   *
   * @description
   * get collection and filter duplicate members
   * if uniqueFilter get a property(nested to) as argument it's
   * filter by this property as unique identifier
   */
  
  angular.module('a8m.unique', [])
    .filter({
        unique: ['$parse', uniqFilter],
        uniq: ['$parse', uniqFilter]
      });
  
  function uniqFilter($parse) {
      return function (collection, property) {
  
        collection = isObject(collection) ? toArray(collection) : collection;
  
        if (!isArray(collection)) {
          return collection;
        }
  
        //store all unique identifiers
        var uniqueItems = [],
            get = $parse(property);
  
        return (isUndefined(property))
          //if it's kind of primitive array
          ? collection.filter(function (elm, pos, self) {
            return self.indexOf(elm) === pos;
          })
          //else compare with equals
          : collection.filter(function (elm) {
            var prop = get(elm);
            if(some(uniqueItems, prop)) {
              return false;
            }
            uniqueItems.push(prop);
            return true;
        });
  
        //checked if the unique identifier is already exist
        function some(array, member) {
          if(isUndefined(member)) {
            return false;
          }
          return array.some(function(el) {
            return equals(el, member);
          });
        }
      }
  }
  
  /**
   * @ngdoc filter
   * @name where
   * @kind function
   *
   * @description
   * of each element in a collection to the given properties object,
   * returning an array of all elements that have equivalent property values.
   *
   */
  angular.module('a8m.where', [])
    .filter('where', function() {
      return function (collection, object) {
        if(isUndefined(object)) return collection;
        collection = isObject(collection)
          ? toArray(collection)
          : collection;
  
        return collection.filter(function (elm) {
          return objectContains(object, elm);
        });
      }
    });
  
  /**
   * @ngdoc filter
   * @name xor
   * @kind function
   *
   * @description
   * Exclusive or filter by expression
   */
  
  angular.module('a8m.xor', [])
  
    .filter('xor', ['$parse', function($parse) {
      return function (col1, col2, expression) {
  
        expression = expression || false;
  
        col1 = isObject(col1) ? toArray(col1) : col1;
        col2 = isObject(col2) ? toArray(col2) : col2;
  
        if(!isArray(col1) || !isArray(col2)) return col1;
  
        return col1.concat(col2)
          .filter(function(elm) {
            return !(some(elm, col1) && some(elm, col2));
          });
  
        function some(el, col) {
          var getter = $parse(expression);
          return col.some(function(dElm) {
            return expression
              ? equals(getter(dElm), getter(el))
              : equals(dElm, el);
          });
        }
      }
    }]);
  
  /**
   * @ngdoc filter
   * @name formatBytes
   * @kind function
   *
   * @description
   * Convert bytes into appropriate display 
   * 1024 bytes => 1 KB
   */
  angular.module('a8m.math.byteFmt', ['a8m.math'])
    .filter('byteFmt', ['$math', function ($math) {
      return function (bytes, decimal) {
  
        if(isNumber(decimal) && isFinite(decimal) && decimal%1===0 && decimal >= 0 &&
          isNumber(bytes) && isFinite(bytes)) {
          if(bytes < 1024) { // within 1 KB so B
            return convertToDecimal(bytes, decimal, $math) + ' B';
          } else if(bytes < 1048576) { // within 1 MB so KB
            return convertToDecimal((bytes / 1024), decimal, $math) + ' KB';
          } else if(bytes < 1073741824){ // within 1 GB so MB
            return convertToDecimal((bytes / 1048576), decimal, $math) + ' MB';
          } else { // GB or more
            return convertToDecimal((bytes / 1073741824), decimal, $math) + ' GB';
          }
  
        }
        return "NaN";
      }
    }]);
  /**
   * @ngdoc filter
   * @name degrees
   * @kind function
   *
   * @description
   * Convert angle from radians to degrees
   */
  angular.module('a8m.math.degrees', ['a8m.math'])
    .filter('degrees', ['$math', function ($math) {
      return function (radians, decimal) {
        // if decimal is not an integer greater than -1, we cannot do. quit with error "NaN"
        // if degrees is not a real number, we cannot do also. quit with error "NaN"
        if(isNumber(decimal) && isFinite(decimal) && decimal%1===0 && decimal >= 0 &&
          isNumber(radians) && isFinite(radians)) {
          var degrees = (radians * 180) / $math.PI;
          return $math.round(degrees * $math.pow(10,decimal)) / ($math.pow(10,decimal));
        } else {
          return "NaN";
        }
      }
    }]);
  
   
   
  /**
   * @ngdoc filter
   * @name formatBytes
   * @kind function
   *
   * @description
   * Convert bytes into appropriate display 
   * 1024 kilobytes => 1 MB
   */
  angular.module('a8m.math.kbFmt', ['a8m.math'])
    .filter('kbFmt', ['$math', function ($math) {
      return function (bytes, decimal) {
  
        if(isNumber(decimal) && isFinite(decimal) && decimal%1===0 && decimal >= 0 &&
          isNumber(bytes) && isFinite(bytes)) {
          if(bytes < 1024) { // within 1 MB so KB
            return convertToDecimal(bytes, decimal, $math) + ' KB';
          } else if(bytes < 1048576) { // within 1 GB so MB
            return convertToDecimal((bytes / 1024), decimal, $math) + ' MB';
          } else {
            return convertToDecimal((bytes / 1048576), decimal, $math) + ' GB';
          }
        }
        return "NaN";
      }
    }]);
  /**
   * @ngdoc module
   * @name math
   * @description
   * reference to global Math object
   */
  angular.module('a8m.math', [])
    .factory('$math', ['$window', function ($window) {
      return $window.Math;
    }]);
  
  /**
   * @ngdoc filter
   * @name max
   * @kind function
   *
   * @description
   * Math.max will get an array and return the max value. if an expression
   * is provided, will return max value by expression.
   */
  angular.module('a8m.math.max', ['a8m.math'])
    .filter('max', ['$math', '$parse', function ($math, $parse) {
      return function (input, expression) {
  
        if(!isArray(input)) {
          return input;
        }
        return isUndefined(expression)
          ? $math.max.apply($math, input)
          : input[indexByMax(input, expression)];
      };
  
      /**
       * @private
       * @param array
       * @param exp
       * @returns {number|*|Number}
       */
      function indexByMax(array, exp) {
        var mappedArray = array.map(function(elm){
          return $parse(exp)(elm);
        });
        return mappedArray.indexOf($math.max.apply($math, mappedArray));
      }
    }]);
  /**
   * @ngdoc filter
   * @name min
   * @kind function
   *
   * @description
   * Math.min will get an array and return the min value. if an expression
   * is provided, will return min value by expression.
   */
  angular.module('a8m.math.min', ['a8m.math'])
    .filter('min', ['$math', '$parse', function ($math, $parse) {
      return function (input, expression) {
  
        if(!isArray(input)) {
          return input;
        }
        return isUndefined(expression)
          ? $math.min.apply($math, input)
          : input[indexByMin(input, expression)];
      };
  
      /**
       * @private
       * @param array
       * @param exp
       * @returns {number|*|Number}
       */
      function indexByMin(array, exp) {
        var mappedArray = array.map(function(elm){
          return $parse(exp)(elm);
        });
        return mappedArray.indexOf($math.min.apply($math, mappedArray));
      }
    }]);
  /**
   * @ngdoc filter
   * @name Percent
   * @kind function
   *
   * @description
   * percentage between two numbers
   */
  angular.module('a8m.math.percent', ['a8m.math'])
    .filter('percent', ['$math', '$window', function ($math, $window) {
      return function (input, divided, round) {
  
        var divider = isString(input) ? $window.Number(input) : input;
        divided = divided || 100;
        round = round || false;
  
        if (!isNumber(divider) || $window.isNaN(divider)) return input;
  
        return round
          ? $math.round((divider / divided) * 100)
          : (divider / divided) * 100;
      }
    }]);
  
  /**
   * @ngdoc filter
   * @name toRadians
   * @kind function
   *
   * @description
   * Convert angle from degrees to radians
   */
  angular.module('a8m.math.radians', ['a8m.math'])
    .filter('radians', ['$math', function ($math) {
      return function (degrees, decimal) {
        // if decimal is not an integer greater than -1, we cannot do. quit with error "NaN"
        // if degrees is not a real number, we cannot do also. quit with error "NaN"
        if(isNumber(decimal) && isFinite(decimal) && decimal%1===0 && decimal >= 0 &&
          isNumber(degrees) && isFinite(degrees)) {
          var radians = (degrees * 3.14159265359) / 180;
          return $math.round(radians * $math.pow(10,decimal)) / ($math.pow(10,decimal));
        }
        return "NaN";
      }
    }]);
  
   
   
  /**
   * @ngdoc filter
   * @name Radix
   * @kind function
   *
   * @description
   * converting decimal numbers to different bases(radix)
   */
  angular.module('a8m.math.radix', [])
    .filter('radix', function () {
      return function (input, radix) {
        var RANGE = /^[2-9]$|^[1-2]\d$|^3[0-6]$/;
  
        if(!isNumber(input) || !RANGE.test(radix)) {
          return input;
        }
  
        return input.toString(radix).toUpperCase();
      }
    });
  
  /**
   * @ngdoc filter
   * @name formatBytes
   * @kind function
   *
   * @description
   * Convert number into abbreviations.
   * i.e: K for one thousand, M for Million, B for billion
   * e.g: number of users:235,221, decimal:1 => 235.2 K
   */
  angular.module('a8m.math.shortFmt', ['a8m.math'])
    .filter('shortFmt', ['$math', function ($math) {
      return function (number, decimal) {
        if(isNumber(decimal) && isFinite(decimal) && decimal%1===0 && decimal >= 0 &&
          isNumber(number) && isFinite(number)){
          if(number < 1e3) {
            return number;
          } else if(number < 1e6) {
            return convertToDecimal((number / 1e3), decimal, $math) + ' K';
          } else if(number < 1e9){
            return convertToDecimal((number / 1e6), decimal, $math) + ' M';
          } else {
            return convertToDecimal((number / 1e9), decimal, $math) + ' B';
          }
  
        }
        return "NaN";
      }
    }]);
  /**
   * @ngdoc filter
   * @name sum
   * @kind function
   *
   * @description
   * Sum up all values within an array
   */
  angular.module('a8m.math.sum', [])
    .filter('sum', function () {
      return function (input, initial) {
        return !isArray(input)
          ? input
          : input.reduce(function(prev, curr) {
            return prev + curr;
          }, initial || 0);
      }
    });
  
  /**
   * @ngdoc filter
   * @name endsWith
   * @kind function
   *
   * @description
   * checks whether string ends with the ends parameter.
   */
  angular.module('a8m.ends-with', [])
  
    .filter('endsWith', function () {
      return function (input, ends, csensitive) {
  
        var sensitive = csensitive || false,
          position;
  
        if(!isString(input) || isUndefined(ends)) {
          return input;
        }
  
        input = (sensitive) ? input : input.toLowerCase();
        position = input.length - ends.length;
  
        return input.indexOf((sensitive) ? ends : ends.toLowerCase(), position) !== -1;
      }
    });
  
  /**
   * @ngdoc filter
   * @name latinize
   * @kind function
   *
   * @description
   * remove accents/diacritics from a string
   */
  angular.module('a8m.latinize', [])
    .filter('latinize',[ function () {
      var defaultDiacriticsRemovalap = [
        {'base':'A', 'letters':'\u0041\u24B6\uFF21\u00C0\u00C1\u00C2\u1EA6\u1EA4\u1EAA\u1EA8\u00C3\u0100\u0102\u1EB0\u1EAE\u1EB4\u1EB2\u0226\u01E0\u00C4\u01DE\u1EA2\u00C5\u01FA\u01CD\u0200\u0202\u1EA0\u1EAC\u1EB6\u1E00\u0104\u023A\u2C6F'},
        {'base':'AA','letters':'\uA732'},
        {'base':'AE','letters':'\u00C6\u01FC\u01E2'},
        {'base':'AO','letters':'\uA734'},
        {'base':'AU','letters':'\uA736'},
        {'base':'AV','letters':'\uA738\uA73A'},
        {'base':'AY','letters':'\uA73C'},
        {'base':'B', 'letters':'\u0042\u24B7\uFF22\u1E02\u1E04\u1E06\u0243\u0182\u0181'},
        {'base':'C', 'letters':'\u0043\u24B8\uFF23\u0106\u0108\u010A\u010C\u00C7\u1E08\u0187\u023B\uA73E'},
        {'base':'D', 'letters':'\u0044\u24B9\uFF24\u1E0A\u010E\u1E0C\u1E10\u1E12\u1E0E\u0110\u018B\u018A\u0189\uA779'},
        {'base':'DZ','letters':'\u01F1\u01C4'},
        {'base':'Dz','letters':'\u01F2\u01C5'},
        {'base':'E', 'letters':'\u0045\u24BA\uFF25\u00C8\u00C9\u00CA\u1EC0\u1EBE\u1EC4\u1EC2\u1EBC\u0112\u1E14\u1E16\u0114\u0116\u00CB\u1EBA\u011A\u0204\u0206\u1EB8\u1EC6\u0228\u1E1C\u0118\u1E18\u1E1A\u0190\u018E'},
        {'base':'F', 'letters':'\u0046\u24BB\uFF26\u1E1E\u0191\uA77B'},
        {'base':'G', 'letters':'\u0047\u24BC\uFF27\u01F4\u011C\u1E20\u011E\u0120\u01E6\u0122\u01E4\u0193\uA7A0\uA77D\uA77E'},
        {'base':'H', 'letters':'\u0048\u24BD\uFF28\u0124\u1E22\u1E26\u021E\u1E24\u1E28\u1E2A\u0126\u2C67\u2C75\uA78D'},
        {'base':'I', 'letters':'\u0049\u24BE\uFF29\u00CC\u00CD\u00CE\u0128\u012A\u012C\u0130\u00CF\u1E2E\u1EC8\u01CF\u0208\u020A\u1ECA\u012E\u1E2C\u0197'},
        {'base':'J', 'letters':'\u004A\u24BF\uFF2A\u0134\u0248'},
        {'base':'K', 'letters':'\u004B\u24C0\uFF2B\u1E30\u01E8\u1E32\u0136\u1E34\u0198\u2C69\uA740\uA742\uA744\uA7A2'},
        {'base':'L', 'letters':'\u004C\u24C1\uFF2C\u013F\u0139\u013D\u1E36\u1E38\u013B\u1E3C\u1E3A\u0141\u023D\u2C62\u2C60\uA748\uA746\uA780'},
        {'base':'LJ','letters':'\u01C7'},
        {'base':'Lj','letters':'\u01C8'},
        {'base':'M', 'letters':'\u004D\u24C2\uFF2D\u1E3E\u1E40\u1E42\u2C6E\u019C'},
        {'base':'N', 'letters':'\u004E\u24C3\uFF2E\u01F8\u0143\u00D1\u1E44\u0147\u1E46\u0145\u1E4A\u1E48\u0220\u019D\uA790\uA7A4'},
        {'base':'NJ','letters':'\u01CA'},
        {'base':'Nj','letters':'\u01CB'},
        {'base':'O', 'letters':'\u004F\u24C4\uFF2F\u00D2\u00D3\u00D4\u1ED2\u1ED0\u1ED6\u1ED4\u00D5\u1E4C\u022C\u1E4E\u014C\u1E50\u1E52\u014E\u022E\u0230\u00D6\u022A\u1ECE\u0150\u01D1\u020C\u020E\u01A0\u1EDC\u1EDA\u1EE0\u1EDE\u1EE2\u1ECC\u1ED8\u01EA\u01EC\u00D8\u01FE\u0186\u019F\uA74A\uA74C'},
        {'base':'OI','letters':'\u01A2'},
        {'base':'OO','letters':'\uA74E'},
        {'base':'OU','letters':'\u0222'},
        {'base':'OE','letters':'\u008C\u0152'},
        {'base':'oe','letters':'\u009C\u0153'},
        {'base':'P', 'letters':'\u0050\u24C5\uFF30\u1E54\u1E56\u01A4\u2C63\uA750\uA752\uA754'},
        {'base':'Q', 'letters':'\u0051\u24C6\uFF31\uA756\uA758\u024A'},
        {'base':'R', 'letters':'\u0052\u24C7\uFF32\u0154\u1E58\u0158\u0210\u0212\u1E5A\u1E5C\u0156\u1E5E\u024C\u2C64\uA75A\uA7A6\uA782'},
        {'base':'S', 'letters':'\u0053\u24C8\uFF33\u1E9E\u015A\u1E64\u015C\u1E60\u0160\u1E66\u1E62\u1E68\u0218\u015E\u2C7E\uA7A8\uA784'},
        {'base':'T', 'letters':'\u0054\u24C9\uFF34\u1E6A\u0164\u1E6C\u021A\u0162\u1E70\u1E6E\u0166\u01AC\u01AE\u023E\uA786'},
        {'base':'TZ','letters':'\uA728'},
        {'base':'U', 'letters':'\u0055\u24CA\uFF35\u00D9\u00DA\u00DB\u0168\u1E78\u016A\u1E7A\u016C\u00DC\u01DB\u01D7\u01D5\u01D9\u1EE6\u016E\u0170\u01D3\u0214\u0216\u01AF\u1EEA\u1EE8\u1EEE\u1EEC\u1EF0\u1EE4\u1E72\u0172\u1E76\u1E74\u0244'},
        {'base':'V', 'letters':'\u0056\u24CB\uFF36\u1E7C\u1E7E\u01B2\uA75E\u0245'},
        {'base':'VY','letters':'\uA760'},
        {'base':'W', 'letters':'\u0057\u24CC\uFF37\u1E80\u1E82\u0174\u1E86\u1E84\u1E88\u2C72'},
        {'base':'X', 'letters':'\u0058\u24CD\uFF38\u1E8A\u1E8C'},
        {'base':'Y', 'letters':'\u0059\u24CE\uFF39\u1EF2\u00DD\u0176\u1EF8\u0232\u1E8E\u0178\u1EF6\u1EF4\u01B3\u024E\u1EFE'},
        {'base':'Z', 'letters':'\u005A\u24CF\uFF3A\u0179\u1E90\u017B\u017D\u1E92\u1E94\u01B5\u0224\u2C7F\u2C6B\uA762'},
        {'base':'a', 'letters':'\u0061\u24D0\uFF41\u1E9A\u00E0\u00E1\u00E2\u1EA7\u1EA5\u1EAB\u1EA9\u00E3\u0101\u0103\u1EB1\u1EAF\u1EB5\u1EB3\u0227\u01E1\u00E4\u01DF\u1EA3\u00E5\u01FB\u01CE\u0201\u0203\u1EA1\u1EAD\u1EB7\u1E01\u0105\u2C65\u0250'},
        {'base':'aa','letters':'\uA733'},
        {'base':'ae','letters':'\u00E6\u01FD\u01E3'},
        {'base':'ao','letters':'\uA735'},
        {'base':'au','letters':'\uA737'},
        {'base':'av','letters':'\uA739\uA73B'},
        {'base':'ay','letters':'\uA73D'},
        {'base':'b', 'letters':'\u0062\u24D1\uFF42\u1E03\u1E05\u1E07\u0180\u0183\u0253'},
        {'base':'c', 'letters':'\u0063\u24D2\uFF43\u0107\u0109\u010B\u010D\u00E7\u1E09\u0188\u023C\uA73F\u2184'},
        {'base':'d', 'letters':'\u0064\u24D3\uFF44\u1E0B\u010F\u1E0D\u1E11\u1E13\u1E0F\u0111\u018C\u0256\u0257\uA77A'},
        {'base':'dz','letters':'\u01F3\u01C6'},
        {'base':'e', 'letters':'\u0065\u24D4\uFF45\u00E8\u00E9\u00EA\u1EC1\u1EBF\u1EC5\u1EC3\u1EBD\u0113\u1E15\u1E17\u0115\u0117\u00EB\u1EBB\u011B\u0205\u0207\u1EB9\u1EC7\u0229\u1E1D\u0119\u1E19\u1E1B\u0247\u025B\u01DD'},
        {'base':'f', 'letters':'\u0066\u24D5\uFF46\u1E1F\u0192\uA77C'},
        {'base':'g', 'letters':'\u0067\u24D6\uFF47\u01F5\u011D\u1E21\u011F\u0121\u01E7\u0123\u01E5\u0260\uA7A1\u1D79\uA77F'},
        {'base':'h', 'letters':'\u0068\u24D7\uFF48\u0125\u1E23\u1E27\u021F\u1E25\u1E29\u1E2B\u1E96\u0127\u2C68\u2C76\u0265'},
        {'base':'hv','letters':'\u0195'},
        {'base':'i', 'letters':'\u0069\u24D8\uFF49\u00EC\u00ED\u00EE\u0129\u012B\u012D\u00EF\u1E2F\u1EC9\u01D0\u0209\u020B\u1ECB\u012F\u1E2D\u0268\u0131'},
        {'base':'j', 'letters':'\u006A\u24D9\uFF4A\u0135\u01F0\u0249'},
        {'base':'k', 'letters':'\u006B\u24DA\uFF4B\u1E31\u01E9\u1E33\u0137\u1E35\u0199\u2C6A\uA741\uA743\uA745\uA7A3'},
        {'base':'l', 'letters':'\u006C\u24DB\uFF4C\u0140\u013A\u013E\u1E37\u1E39\u013C\u1E3D\u1E3B\u017F\u0142\u019A\u026B\u2C61\uA749\uA781\uA747'},
        {'base':'lj','letters':'\u01C9'},
        {'base':'m', 'letters':'\u006D\u24DC\uFF4D\u1E3F\u1E41\u1E43\u0271\u026F'},
        {'base':'n', 'letters':'\u006E\u24DD\uFF4E\u01F9\u0144\u00F1\u1E45\u0148\u1E47\u0146\u1E4B\u1E49\u019E\u0272\u0149\uA791\uA7A5'},
        {'base':'nj','letters':'\u01CC'},
        {'base':'o', 'letters':'\u006F\u24DE\uFF4F\u00F2\u00F3\u00F4\u1ED3\u1ED1\u1ED7\u1ED5\u00F5\u1E4D\u022D\u1E4F\u014D\u1E51\u1E53\u014F\u022F\u0231\u00F6\u022B\u1ECF\u0151\u01D2\u020D\u020F\u01A1\u1EDD\u1EDB\u1EE1\u1EDF\u1EE3\u1ECD\u1ED9\u01EB\u01ED\u00F8\u01FF\u0254\uA74B\uA74D\u0275'},
        {'base':'oi','letters':'\u01A3'},
        {'base':'ou','letters':'\u0223'},
        {'base':'oo','letters':'\uA74F'},
        {'base':'p','letters':'\u0070\u24DF\uFF50\u1E55\u1E57\u01A5\u1D7D\uA751\uA753\uA755'},
        {'base':'q','letters':'\u0071\u24E0\uFF51\u024B\uA757\uA759'},
        {'base':'r','letters':'\u0072\u24E1\uFF52\u0155\u1E59\u0159\u0211\u0213\u1E5B\u1E5D\u0157\u1E5F\u024D\u027D\uA75B\uA7A7\uA783'},
        {'base':'s','letters':'\u0073\u24E2\uFF53\u00DF\u015B\u1E65\u015D\u1E61\u0161\u1E67\u1E63\u1E69\u0219\u015F\u023F\uA7A9\uA785\u1E9B'},
        {'base':'t','letters':'\u0074\u24E3\uFF54\u1E6B\u1E97\u0165\u1E6D\u021B\u0163\u1E71\u1E6F\u0167\u01AD\u0288\u2C66\uA787'},
        {'base':'tz','letters':'\uA729'},
        {'base':'u','letters': '\u0075\u24E4\uFF55\u00F9\u00FA\u00FB\u0169\u1E79\u016B\u1E7B\u016D\u00FC\u01DC\u01D8\u01D6\u01DA\u1EE7\u016F\u0171\u01D4\u0215\u0217\u01B0\u1EEB\u1EE9\u1EEF\u1EED\u1EF1\u1EE5\u1E73\u0173\u1E77\u1E75\u0289'},
        {'base':'v','letters':'\u0076\u24E5\uFF56\u1E7D\u1E7F\u028B\uA75F\u028C'},
        {'base':'vy','letters':'\uA761'},
        {'base':'w','letters':'\u0077\u24E6\uFF57\u1E81\u1E83\u0175\u1E87\u1E85\u1E98\u1E89\u2C73'},
        {'base':'x','letters':'\u0078\u24E7\uFF58\u1E8B\u1E8D'},
        {'base':'y','letters':'\u0079\u24E8\uFF59\u1EF3\u00FD\u0177\u1EF9\u0233\u1E8F\u00FF\u1EF7\u1E99\u1EF5\u01B4\u024F\u1EFF'},
        {'base':'z','letters':'\u007A\u24E9\uFF5A\u017A\u1E91\u017C\u017E\u1E93\u1E95\u01B6\u0225\u0240\u2C6C\uA763'}
      ];
  
      var diacriticsMap = {};
      for (var i = 0; i < defaultDiacriticsRemovalap.length; i++) {
        var letters = defaultDiacriticsRemovalap[i].letters.split("");
        for (var j = 0; j < letters.length ; j++){
          diacriticsMap[letters[j]] = defaultDiacriticsRemovalap[i].base;
        }
      }
  
      // "what?" version ... http://jsperf.com/diacritics/12
      function removeDiacritics (str) {
        return str.replace(/[^\u0000-\u007E]/g, function(a){
          return diacriticsMap[a] || a;
        });
      }
  
      return function (input) {
  
        return isString(input)
          ? removeDiacritics(input)
          : input;
      }
    }]);
  
  /**
   * @ngdoc filter
   * @name ltrim
   * @kind function
   *
   * @description
   * Left trim. Similar to trimFilter, but only for left side.
   */
  angular.module('a8m.ltrim', [])
    .filter('ltrim', function () {
      return function(input, chars) {
  
        var trim = chars || '\\s';
  
        return isString(input)
          ? input.replace(new RegExp('^' + trim + '+'), '')
          : input;
      }
    });
  
  /**
   * @ngdoc filter
   * @name match
   * @kind function
   *
   * @description
   * Return the matched pattern in a string.
   */
  angular.module('a8m.match', [])
    .filter('match', function () {
      return function (input, pattern, flag) {
  
        var reg = new RegExp(pattern, flag);
  
        return isString(input)
          ? input.match(reg)
          : null;
      }
    });
  
  /**
   * @ngdoc filter
   * @name repeat
   * @kind function
   *
   * @description
   * Repeats a string n times
   */
  angular.module('a8m.repeat', [])
    .filter('repeat',[ function () {
      return function (input, n, separator) {
  
        var times = ~~n;
  
        if(!isString(input)) {
          return input;
        }
  
        return !times
          ? input
          : strRepeat(input, --n, separator || '');
      }
    }]);
  
  /**
   * Repeats a string n times with given separator
   * @param str string to repeat
   * @param n number of times
   * @param sep separator
   * @returns {*}
   */
  function strRepeat(str, n, sep) {
    if(!n) {
      return str;
    }
    return str + sep + strRepeat(str, --n, sep);
  }
  /**
  * @ngdoc filter
  * @name rtrim
  * @kind function
  *
  * @description
  * Right trim. Similar to trimFilter, but only for right side.
  */
  angular.module('a8m.rtrim', [])
    .filter('rtrim', function () {
      return function(input, chars) {
  
        var trim = chars || '\\s';
  
        return isString(input)
          ? input.replace(new RegExp(trim + '+$'), '')
          : input;
      }
    });
  
  /**
   * @ngdoc filter
   * @name slugify
   * @kind function
   *
   * @description
   * remove spaces from string, replace with "-" or given argument
   */
  angular.module('a8m.slugify', [])
    .filter('slugify',[ function () {
      return function (input, sub) {
  
        var replace = (isUndefined(sub)) ? '-' : sub;
  
        return isString(input)
          ? input.toLowerCase().replace(/\s+/g, replace)
          : input;
      }
    }]);
  
  /**
   * @ngdoc filter
   * @name startWith
   * @kind function
   *
   * @description
   * checks whether string starts with the starts parameter.
   */
  angular.module('a8m.starts-with', [])
    .filter('startsWith', function () {
      return function (input, start, csensitive) {
  
        var sensitive = csensitive || false;
  
        if(!isString(input) || isUndefined(start)) {
          return input;
        }
  
        input = (sensitive) ? input : input.toLowerCase();
  
        return !input.indexOf((sensitive) ? start : start.toLowerCase());
      }
    });
  
  /**
   * @ngdoc filter
   * @name stringular
   * @kind function
   *
   * @description
   * get string with {n} and replace match with enumeration values
   */
  angular.module('a8m.stringular', [])
    .filter('stringular', function () {
      return function(input) {
  
        var args = Array.prototype.slice.call(arguments, 1);
  
        return input.replace(/{(\d+)}/g, function (match, number) {
          return isUndefined(args[number]) ? match : args[number];
        });
      }
    });
  
  /**
   * @ngdoc filter
   * @name stripTags
   * @kind function
   *
   * @description
   * strip html tags from string
   */
  angular.module('a8m.strip-tags', [])
    .filter('stripTags', function () {
      return function(input) {
        return isString(input)
          ? input.replace(/<\S[^><]*>/g, '')
          : input;
      }
    });
  
  /**
   * @ngdoc filter
   * @name test
   * @kind function
   *
   * @description
   * test if a string match a pattern.
   */
  angular.module('a8m.test', [])
    .filter('test', function () {
      return function (input, pattern, flag) {
  
        var reg = new RegExp(pattern, flag);
  
        return isString(input)
          ? reg.test(input)
          : input;
      }
    });
  
  /**
   * @ngdoc filter
   * @name trim
   * @kind function
   *
   * @description
   *  Strip whitespace (or other characters) from the beginning and end of a string
   */
  angular.module('a8m.trim', [])
    .filter('trim', function () {
      return function(input, chars) {
  
        var trim = chars || '\\s';
  
        return isString(input)
          ? input.replace(new RegExp('^' + trim + '+|' + trim + '+$', 'g'), '')
          : input;
      }
    });
  
  /**
   * @ngdoc filter
   * @name truncate
   * @kind function
   *
   * @description
   * truncates a string given a specified length, providing a custom string to denote an omission.
   */
  angular.module('a8m.truncate', [])
    .filter('truncate', function () {
      return function(input, length, suffix, preserve) {
  
        length = isUndefined(length) ? input.length : length;
        preserve = preserve || false;
        suffix = suffix || '';
  
        if(!isString(input) || (input.length <= length)) return input;
  
        return input.substring(0, (preserve)
          ? ((input.indexOf(' ', length) === -1) ? input.length : input.indexOf(' ', length))
          : length) + suffix;
      };
    });
  
  /**
   * @ngdoc filter
   * @name ucfirst
   * @kind function
   *
   * @description
   * ucfirst
   */
  angular.module('a8m.ucfirst', [])
    .filter('ucfirst', [function() {
      return function(input) {
        return isString(input)
          ? input
              .split(' ')
              .map(function (ch) {
                return ch.charAt(0).toUpperCase() + ch.substring(1);
              })
              .join(' ')
          : input;
      }
    }]);
  
  /**
   * @ngdoc filter
   * @name uriComponentEncode
   * @kind function
   *
   * @description
   * get string as parameter and return encoded string
   */
  angular.module('a8m.uri-component-encode', [])
    .filter('uriComponentEncode',['$window', function ($window) {
        return function (input) {
          return isString(input)
            ? $window.encodeURIComponent(input)
            : input;
        }
      }]);
  
  /**
   * @ngdoc filter
   * @name uriEncode
   * @kind function
   *
   * @description
   * get string as parameter and return encoded string
   */
  angular.module('a8m.uri-encode', [])
    .filter('uriEncode',['$window', function ($window) {
        return function (input) {
          return isString(input)
            ? $window.encodeURI(input)
            : input;
        }
      }]);
  
  /**
   * @ngdoc filter
   * @name wrap
   * @kind function
   *
   * @description
   * Wrap a string with another string
   */
  angular.module('a8m.wrap', [])
    .filter('wrap', function () {
      return function(input, wrap, ends) {
        return isString(input) && isDefined(wrap)
          ? [wrap, input, ends || wrap].join('')
          : input;
      }
    });
  
  /**
   * @ngdoc provider
   * @name filterWatcher
   * @kind function
   *
   * @description
   * store specific filters result in $$cache, based on scope life time(avoid memory leak).
   * on scope.$destroy remove it's cache from $$cache container
   */
  
  angular.module('a8m.filter-watcher', [])
    .provider('filterWatcher', function() {
  
      this.$get = ['$window', '$rootScope', function($window, $rootScope) {
  
        /**
         * Cache storing
         * @type {Object}
         */
        var $$cache = {};
  
        /**
         * Scope listeners container
         * scope.$destroy => remove all cache keys
         * bind to current scope.
         * @type {Object}
         */
        var $$listeners = {};
  
        /**
         * $timeout without triggering the digest cycle
         * @type {function}
         */
        var $$timeout = $window.setTimeout;
  
        /**
         * @description
         * get `HashKey` string based on the given arguments.
         * @param fName
         * @param args
         * @returns {string}
         */
        function getHashKey(fName, args) {
          function replacerFactory() {
            var cache = [];
            return function(key, val) {
              if(isObject(val) && !isNull(val)) {
                if (~cache.indexOf(val)) return '[Circular]';
                cache.push(val)
              }
              if($window == val) return '$WINDOW';
              if($window.document == val) return '$DOCUMENT';
              if(isScope(val)) return '$SCOPE';
              return val;
            }
          }
          return [fName, JSON.stringify(args, replacerFactory())]
            .join('#')
            .replace(/"/g,'');
        }
  
        /**
         * @description
         * fir on $scope.$destroy,
         * remove cache based scope from `$$cache`,
         * and remove itself from `$$listeners`
         * @param event
         */
        function removeCache(event) {
          var id = event.targetScope.$id;
          forEach($$listeners[id], function(key) {
            delete $$cache[key];
          });
          delete $$listeners[id];
        }
  
        /**
         * @description
         * for angular version that greater than v.1.3.0
         * it clear cache when the digest cycle is end.
         */
        function cleanStateless() {
          $$timeout(function() {
            if(!$rootScope.$$phase)
              $$cache = {};
          }, 2000);
        }
  
        /**
         * @description
         * Store hashKeys in $$listeners container
         * on scope.$destroy, remove them all(bind an event).
         * @param scope
         * @param hashKey
         * @returns {*}
         */
        function addListener(scope, hashKey) {
          var id = scope.$id;
          if(isUndefined($$listeners[id])) {
            scope.$on('$destroy', removeCache);
            $$listeners[id] = [];
          }
          return $$listeners[id].push(hashKey);
        }
  
        /**
         * @description
         * return the `cacheKey` or undefined.
         * @param filterName
         * @param args
         * @returns {*}
         */
        function $$isMemoized(filterName, args) {
          var hashKey = getHashKey(filterName, args);
          return $$cache[hashKey];
        }
  
        /**
         * @description
         * store `result` in `$$cache` container, based on the hashKey.
         * add $destroy listener and return result
         * @param filterName
         * @param args
         * @param scope
         * @param result
         * @returns {*}
         */
        function $$memoize(filterName, args, scope, result) {
          var hashKey = getHashKey(filterName, args);
          //store result in `$$cache` container
          $$cache[hashKey] = result;
          // for angular versions that less than 1.3
          // add to `$destroy` listener, a cleaner callback
          if(isScope(scope)) {
            addListener(scope, hashKey);
          } else {
            cleanStateless();
          }
          return result;
        }
  
        return {
          isMemoized: $$isMemoized,
          memoize: $$memoize
        }
      }];
    });
    
  
  /**
   * @ngdoc module
   * @name angular.filters
   * @description
   * Bunch of useful filters for angularJS
   */
  
  angular.module('angular.filter', [
  
    'a8m.ucfirst',
    'a8m.uri-encode',
    'a8m.uri-component-encode',
    'a8m.slugify',
    'a8m.latinize',
    'a8m.strip-tags',
    'a8m.stringular',
    'a8m.truncate',
    'a8m.starts-with',
    'a8m.ends-with',
    'a8m.wrap',
    'a8m.trim',
    'a8m.ltrim',
    'a8m.rtrim',
    'a8m.repeat',
    'a8m.test',
    'a8m.match',
  
    'a8m.to-array',
    'a8m.concat',
    'a8m.contains',
    'a8m.unique',
    'a8m.is-empty',
    'a8m.after',
    'a8m.after-where',
    'a8m.before',
    'a8m.before-where',
    'a8m.defaults',
    'a8m.where',
    'a8m.reverse',
    'a8m.remove',
    'a8m.remove-with',
    'a8m.group-by',
    'a8m.count-by',
    'a8m.chunk-by',
    'a8m.search-field',
    'a8m.fuzzy-by',
    'a8m.fuzzy',
    'a8m.omit',
    'a8m.pick',
    'a8m.every',
    'a8m.filter-by',
    'a8m.xor',
    'a8m.map',
    'a8m.first',
    'a8m.last',
    'a8m.flatten',
    'a8m.join',
    'a8m.range',
    
    'a8m.math',
    'a8m.math.max',
    'a8m.math.min',
    'a8m.math.percent',
    'a8m.math.radix',
    'a8m.math.sum',
    'a8m.math.degrees',
    'a8m.math.radians',
    'a8m.math.byteFmt',
    'a8m.math.kbFmt',
    'a8m.math.shortFmt',
  
    'a8m.angular',
    'a8m.conditions',
    'a8m.is-null',
  
    'a8m.filter-watcher'
  ]);
  })( window, window.angular );