text: /*
      Validator v1.1.0
      (c) Yair Even Or
      https://github.com/yairEO/validator
  
      MIT-style license.
  */
  
  var validator = (function($){
      var message, tests, checkField, validate, mark, unmark, field, minmax, defaults,
          validateWords, lengthRange, lengthLimit, pattern, alertTxt, data,
          email_illegalChars = /[\(\)\<\>\,\;\:\\\/\"\[\]]/,
          email_filter = /^.+@.+\..{2,6}$/;  // exmaple email "steve@s-i.photo"
  
      /* general text messages
      */
      message = {
          invalid         : 'Invalid input',
          checked         : 'Must be checked',
          empty           : 'Please put something here',
          min             : 'Input is too short',
          max             : 'Input is too long',
          number_min      : 'Too low',
          number_max      : 'Too high',
          url             : 'Invalid URL',
          number          : 'Not a number',
          email           : 'Email address is invalid',
          email_repeat    : 'Emails do not match',
          password        : 'Password minimum 8 character length',
          password_repeat : 'Passwords do not match',
          repeat          : 'No match',
          complete        : 'Input is not complete.<br>Make sure it proper length',
          select          : 'Please select an option'
      };
  
      if(!window.console){
          console={};
          console.log=console.warn=function(){ return; }
      }
  
      // defaults
      defaults = {
          alerts  : true,
          classes : {
  	        item    : 'item',
  	        alert   : 'alert',
  	        bad     : 'bad'
          }
      };
  
      /* Tests for each type of field (including Select element)
      */
      tests = {
          sameAsPlaceholder : function(a){
              return $.fn.placeholder && a.attr('placeholder') !== undefined && data.val == a.prop('placeholder');
          },
          hasValue : function(a){
              if( !a ){
                  alertTxt = message.empty;
                  return false;
              }
              return true;
          },
          // 'linked' is a special test case for inputs which their values should be equal to each other (ex. confirm email or retype password)
          linked : function(a,b){
              if( b != a ){
                  // choose a specific message or a general one
                  alertTxt = message[data.type + '_repeat'] || message.no_match;
                  return false;
              }
              return true;
          },
          email : function(a){
              if ( !email_filter.test( a ) || a.match( email_illegalChars ) ){
                  alertTxt = a ? message.email : message.empty;
                  return false;
              }
              return true;
          },
          // a "skip" will skip some of the tests (needed for keydown validation)
          text : function(a, skip){
              // make sure there are at least X number of words, each at least 2 chars long.
              // for example 'john F kenedy' should be at least 2 words and will pass validation
              if( validateWords ){
                  var words = a.split(' ');
                  // iterrate on all the words
                  var wordsLength = function(len){
                      for( var w = words.length; w--; )
                          if( words[w].length < len )
                              return false;
                      return true;
                  };
  
                  if( words.length < validateWords || !wordsLength(2) ){
                      alertTxt = message.complete;
                      return false;
                  }
                  return true;
              }
              if( !skip && lengthRange && a.length < lengthRange[0] ){
                  alertTxt = message.min;
                  return false;
              }
  
              // check if there is max length & field length is greater than the allowed
              if( lengthRange && lengthRange[1] && a.length > lengthRange[1] ){
                  alertTxt = message.max;
                  return false;
              }
  
              // check if the field's value should obey any length limits, and if so, make sure the length of the value is as specified
              if( lengthLimit && lengthLimit.length ){
                  while( lengthLimit.length ){
                      if( lengthLimit.pop() == a.length ){
                          alertTxt = message.complete;
                          return false;
                      }
                  }
              }
  
              if( pattern ){
                  var regex, jsRegex;
                  switch( pattern ){
                      case 'alphanumeric' :
                          regex = /^[a-zA-Z0-9]+$/i;
                          break;
                      case 'numeric' :
                          regex = /^[0-9]+$/i;
                          break;
                      case 'phone' :
                          regex = /^\+?([0-9]|[-|' '])+$/i;
                          break;
                      default :
                          regex = pattern;
                  }
                  try{
                      jsRegex = new RegExp(regex).test(a);
                      if( a && !jsRegex )
                          return false;
                  }
                  catch(err){
                      console.log(err, field, 'regex is invalid');
                      return false;
                  }
              }
  
              return true;
          },
          number : function(a){
              // if not not a number
              if( isNaN(parseFloat(a)) && !isFinite(a) ){
                  alertTxt = message.number;
                  return false;
              }
              // not enough numbers
              else if( lengthRange && a.length < lengthRange[0] ){
                  alertTxt = message.min;
                  return false;
              }
              // check if there is max length & field length is greater than the allowed
              else if( lengthRange && lengthRange[1] && a.length > lengthRange[1] ){
                  alertTxt = message.max;
                  return false;
              }
              else if( minmax[0] && (a|0) < minmax[0] ){
                  alertTxt = message.number_min;
                  return false;
              }
              else if( minmax[1] && (a|0) > minmax[1] ){
                  alertTxt = message.number_max;
                  return false;
              }
              return true;
          },
          // Date is validated in European format (day,month,year)
          date : function(a){
              var day, A = a.split(/[-./]/g), i;
              // if there is native HTML5 support:
              if( field[0].valueAsNumber )
                  return true;
  
              for( i = A.length; i--; ){
                  if( isNaN(parseFloat(a)) && !isFinite(a) )
                      return false;
              }
              try{
                  day = new Date(A[2], A[1]-1, A[0]);
                  if( day.getMonth()+1 == A[1] && day.getDate() == A[0] )
                      return day;
                  return false;
              }
              catch(er){
                  console.log('date test: ', err);
                  return false;
              }
          },
          url : function(a){
              // minimalistic URL validation
              function testUrl(url){
                  return /^(https?:\/\/)?([\w\d\-_]+\.+[A-Za-z]{2,})+\/?/.test( url );
              }
              if( !testUrl( a ) ){
                  alertTxt = a ? message.url : message.empty;
                  return false;
              }
              return true;
          },
          hidden : function(a){
              if( lengthRange && a.length < lengthRange[0] ){
                  alertTxt = message.min;
                  return false;
              }
              if( pattern ){
                  var regex;
                  if( pattern == 'alphanumeric' ){
                      regex = /^[a-z0-9]+$/i;
                      if( !regex.test(a) ){
                          return false;
                      }
                  }
              }
              return true;
          },
          select : function(a){
              if( !tests.hasValue(a) ){
                  alertTxt = message.select;
                  return false;
              }
              return true;
          }
      };
  
      /* marks invalid fields
      */
      mark = function( field, text ){
          if( !text || !field || !field.length )
              return false;
  
          // check if not already marked as a 'bad' record and add the 'alert' object.
          // if already is marked as 'bad', then make sure the text is set again because i might change depending on validation
          var item = field.closest('.' + defaults.classes.item),
              warning;
  
          if( item.hasClass(defaults.classes.bad) ){
              if( defaults.alerts )
                  item.find('.'+defaults.classes.alert).html(text);
          }
  
  
          else if( defaults.alerts ){
              warning = $('<div class="'+ defaults.classes.alert +'">').html( text );
              item.append( warning );
          }
  
          item.removeClass(defaults.classes.bad);
          // a delay so the "alert" could be transitioned via CSS
          setTimeout(function(){
              item.addClass(defaults.classes.bad);
          }, 0);
      };
      /* un-marks invalid fields
      */
      unmark = function( field ){
          if( !field || !field.length ){
              console.warn('no "field" argument, null or DOM object not found');
              return false;
          }
  
          field.closest('.' + defaults.classes.item)
               .removeClass(defaults.classes.bad)
               .find('.'+ defaults.classes.alert).remove();
      };
  
      function testByType(type, value){
          if( type == 'tel' )
              pattern = pattern || 'phone';
  
          if( !type || type == 'password' || type == 'tel' || type == 'search' || type == 'file' )
              type = 'text';
  
  
          return tests[type] ? tests[type](value, true) : true;
      }
  
      function prepareFieldData(el){
          field = $(el);
  
          field.data( 'valid', true );                // initialize validity of field
          field.data( 'type', field.attr('type') );   // every field starts as 'valid=true' until proven otherwise
          pattern = field.attr('pattern');
      }
  
      /* Validations per-character keypress
      */
      function keypress(e){
          prepareFieldData(this);
          //  String.fromCharCode(e.charCode)
  
          if( e.charCode ){
              return testByType( this.type, this.value );
          }
      }
  
      /* Checks a single form field by it's type and specific (custom) attributes
      */
      function checkField(){
          // skip testing fields whom their type is not HIDDEN but they are HIDDEN via CSS.
          if( this.type !='hidden' && $(this).is(':hidden') )
              return true;
  
          prepareFieldData(this);
  
          field.data( 'val', field[0].value.replace(/^\s+|\s+$/g, "") );  // cache the value of the field and trim it
          data = field.data();
  
          // Check if there is a specific error message for that field, if not, use the default 'invalid' message
          alertTxt = message[field.prop('name')] || message.invalid;
  
          // Special treatment
          if( field[0].nodeName.toLowerCase() === "select" ){
              data.type = 'select';
          }
          else if( field[0].nodeName.toLowerCase() === "textarea" ){
              data.type = 'text';
          }
          /* Gather Custom data attributes for specific validation:
          */
          validateWords   = data['validateWords'] || 0;
          lengthRange     = data['validateLengthRange'] ? (data['validateLengthRange']+'').split(',') : [1];
          lengthLimit     = data['validateLength'] ? (data['validateLength']+'').split(',') : false;
          minmax          = data['validateMinmax'] ? (data['validateMinmax']+'').split(',') : ''; // for type 'number', defines the minimum and/or maximum for the value as a number.
  
          data.valid = tests.hasValue(data.val);
  
          if( field.hasClass('optional') && !data.valid )
              data.valid = true;
  
  
          // for checkboxes
          if( field[0].type === "checkbox" ){
              data.valid = field[0].checked;
              alertTxt = message.checked;
          }
  
          // check if field has any value
          else if( data.valid ){
              /* Validate the field's value is different than the placeholder attribute (and attribute exists)
              * this is needed when fixing the placeholders for older browsers which does not support them.
              * in this case, make sure the "placeholder" jQuery plugin was even used before proceeding
              */
              if( tests.sameAsPlaceholder(field) ){
                  alertTxt = message.empty;
                  data.valid = false;
              }
  
              // if this field is linked to another field (their values should be the same)
              if( data.validateLinked ){
                  var linkedTo = data['validateLinked'].indexOf('#') == 0 ? $(data['validateLinked']) : $(':input[name=' + data['validateLinked'] + ']');
                  data.valid = tests.linked( data.val, linkedTo.val() );
              }
              /* validate by type of field. use 'attr()' is proffered to get the actual value and not what the browsers sees for unsupported types.
              */
              else if( data.valid || data.type == 'select' )
                  data.valid = testByType(data.type, data.val);
  
          }
  
          // mark / unmark the field, and set the general 'submit' flag accordingly
          if( data.valid )
              unmark( field );
          else{
              mark( field, alertTxt );
              submit = false;
          }
  
          return data.valid;
      }
  
      /* vaildates all the REQUIRED fields prior to submiting the form
      */
      function checkAll( $form ){
          $form = $($form);
  
          if( $form.length == 0 ){
              console.warn('element not found');
              return false;
          }
  
          var that = this,
              submit = true, // save the scope
              // get all the input/textareas/select fields which are required or optional (meaning, they need validation only if they were filled)
              fieldsToCheck = $form.find(':input').filter('[required=required], .required, .optional').not('[disabled=disabled]');
  
          fieldsToCheck.each(function(){
              // use an AND operation, so if any of the fields returns 'false' then the submitted result will be also FALSE
              submit = submit * checkField.apply(this);
          });
  
          return !!submit;  // casting the variable to make sure it's a boolean
      }
  
      return {
          defaults    : defaults,
          checkField  : checkField,
          keypress    : keypress,
          checkAll    : checkAll,
          mark        : mark,
          unmark      : unmark,
          message     : message,
          tests       : tests
      }
  })(jQuery);