text: 'use strict';
  
  Object.defineProperty(exports, "__esModule", {
      value: true
  });
  
  var _getPrototypeOf = require('babel-runtime/core-js/object/get-prototype-of');
  
  var _getPrototypeOf2 = _interopRequireDefault(_getPrototypeOf);
  
  var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');
  
  var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
  
  var _createClass2 = require('babel-runtime/helpers/createClass');
  
  var _createClass3 = _interopRequireDefault(_createClass2);
  
  var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn');
  
  var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
  
  var _inherits2 = require('babel-runtime/helpers/inherits');
  
  var _inherits3 = _interopRequireDefault(_inherits2);
  
  var _strict = require('./strict');
  
  var _strict2 = _interopRequireDefault(_strict);
  
  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  
  var ContainsMatcher = function (_StrictMatcher) {
      (0, _inherits3.default)(ContainsMatcher, _StrictMatcher);
  
      function ContainsMatcher() {
          (0, _classCallCheck3.default)(this, ContainsMatcher);
  
          for (var _len = arguments.length, expected = Array(_len), _key = 0; _key < _len; _key++) {
              expected[_key] = arguments[_key];
          }
  
          return (0, _possibleConstructorReturn3.default)(this, (ContainsMatcher.__proto__ || (0, _getPrototypeOf2.default)(ContainsMatcher)).call(this, expected));
      }
  
      (0, _createClass3.default)(ContainsMatcher, [{
          key: 'match',
          value: function match(actual, comparator) {
  
              if (!Array.isArray(actual)) {
  
                  return {
                      match: false,
                      actual: actual,
                      expected: '[an Array]'
                  };
              }
  
              if (!actual.length) {
  
                  return {
                      match: false,
                      actual: actual,
                      expected: '[not an empty Array]'
                  };
              }
  
              var notContained = this.expected.filter(function (expected) {
  
                  return !actual.some(function (el) {
  
                      var elMatcher = new _strict2.default(expected);
  
                      var result = elMatcher.match(el, comparator);
  
                      return result.match;
                  }, this);
              }, this).map(function (expected) {
  
                  var elMatcher = new _strict2.default(expected);
  
                  // use any element of actual array to get expected value of not contained
                  var result = elMatcher.match(actual[0], comparator);
  
                  return result.expected;
              }, this);
  
              if (notContained.length) {
  
                  return {
                      match: false,
                      actual: actual,
                      expected: {
                          '[to contain]': notContained
                      }
                  };
              }
  
              return {
                  match: true,
                  actual: actual,
                  expected: actual
              };
          }
      }]);
      return ContainsMatcher;
  }(_strict2.default);
  
  exports.default = ContainsMatcher;
  module.exports = exports['default'];