bootstrap_validator_rails 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b775517e9b166ac65696deff578593cf7fc36380
-  data.tar.gz: 5f512d9a39b1ed2f9a5020109cd33f7f8e1651ff
+  metadata.gz: f3bcee7c8a61dd91c4e176534d1d3c5d59e2dbad
+  data.tar.gz: fd9254fc410ec6889354067f548c7192e5fbbdae
 SHA512:
-  metadata.gz: e59ff5058adcbb83de1034a997fa7ae384c84abac301b4b66ff0713196477bb87e074352436dddd2ccff45f570d7205a8a2715cafdc11bb8c4bc36f92c8b55f4
-  data.tar.gz: 22bfa58927206c18133ae047a82d1af52a750e3d4da414571accea7b5387f8427d0a138b6d6b03548d9ac5af8354384ee08c44ea1735fc8639eeed06595f39e6
+  metadata.gz: 8fa3b849f5aabed276fb214e81b1453a026ab52f1758e39ba3d9004e2bdc64e3366f61f830e9854ab868957519eb97f59290d832c771c9b150d3927fd15b6152
+  data.tar.gz: a6f054a0355e1123ee92cbb4bd54367025d92230af8556be114ddc05252348284f351e591323c2562bad2e7a5bfd64c74844d067b240a921599b3b6ffa25cb69

data/lib/bootstrap_validator_rails/version.rb

@@ -1,3 +1,3 @@
 module BootstrapValidatorRails
-  VERSION = "0.1.0"
+  VERSION = "0.1.1"
 end

data/vendor/assets/javascripts/bootstrapValidator.js

@@ -1,8 +1,9 @@
-/**
+/*!
  * BootstrapValidator (http://bootstrapvalidator.com)
  * The best jQuery plugin to validate form fields. Designed to use with Bootstrap 3
  *
- * @author      http://twitter.com/nghuuphuoc
+ * @version     v0.5.0, built on 2014-07-14 4:31:02 PM
+ * @author      https://twitter.com/nghuuphuoc
  * @copyright   (c) 2013 - 2014 Nguyen Huu Phuoc
  * @license     MIT
  */
@@ -1801,3 +1802,4677 @@
         }
     };
 }(window.jQuery));
+;(function($) {
+    $.fn.bootstrapValidator.i18n.base64 = $.extend($.fn.bootstrapValidator.i18n.base64 || {}, {
+        'default': 'Please enter a valid base 64 encoded'
+    });
+
+    $.fn.bootstrapValidator.validators.base64 = {
+        /**
+         * Return true if the input value is a base 64 encoded string.
+         *
+         * @param {BootstrapValidator} validator The validator plugin instance
+         * @param {jQuery} $field Field element
+         * @param {Object} options Can consist of the following keys:
+         * - message: The invalid message
+         * @returns {Boolean}
+         */
+        validate: function(validator, $field, options) {
+            var value = $field.val();
+            if (value === '') {
+                return true;
+            }
+
+            return /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=|[A-Za-z0-9+/]{4})$/.test(value);
+        }
+    };
+}(window.jQuery));
+;(function($) {
+    $.fn.bootstrapValidator.i18n.between = $.extend($.fn.bootstrapValidator.i18n.between || {}, {
+        'default': 'Please enter a value between %s and %s',
+        notInclusive: 'Please enter a value between %s and %s strictly'
+    });
+
+    $.fn.bootstrapValidator.validators.between = {
+        html5Attributes: {
+            message: 'message',
+            min: 'min',
+            max: 'max',
+            inclusive: 'inclusive'
+        },
+
+        enableByHtml5: function($field) {
+            if ('range' === $field.attr('type')) {
+                return {
+                    min: $field.attr('min'),
+                    max: $field.attr('max')
+                };
+            }
+
+            return false;
+        },
+
+        /**
+         * Return true if the input value is between (strictly or not) two given numbers
+         *
+         * @param {BootstrapValidator} validator The validator plugin instance
+         * @param {jQuery} $field Field element
+         * @param {Object} options Can consist of the following keys:
+         * - min
+         * - max
+         *
+         * The min, max keys define the number which the field value compares to. min, max can be
+         *      - A number
+         *      - Name of field which its value defines the number
+         *      - Name of callback function that returns the number
+         *      - A callback function that returns the number
+         *
+         * - inclusive [optional]: Can be true or false. Default is true
+         * - message: The invalid message
+         * @returns {Boolean|Object}
+         */
+        validate: function(validator, $field, options) {
+            var value = $field.val();
+            if (value === '') {
+                return true;
+            }
+
+            var min = $.isNumeric(options.min) ? options.min : validator.getDynamicOption($field, options.min),
+                max = $.isNumeric(options.max) ? options.max : validator.getDynamicOption($field, options.max);
+
+            value = parseFloat(value);
+			return (options.inclusive === true || options.inclusive === undefined)
+                    ? {
+                        valid: value >= min && value <= max,
+                        message: $.fn.bootstrapValidator.helpers.format(options.message || $.fn.bootstrapValidator.i18n.between['default'], [min, max])
+                    }
+                    : {
+                        valid: value > min  && value <  max,
+                        message: $.fn.bootstrapValidator.helpers.format(options.message || $.fn.bootstrapValidator.i18n.between.notInclusive, [min, max])
+                    };
+        }
+    };
+}(window.jQuery));
+;(function($) {
+    $.fn.bootstrapValidator.i18n.callback = $.extend($.fn.bootstrapValidator.i18n.callback || {}, {
+        'default': 'Please enter a valid value'
+    });
+
+    $.fn.bootstrapValidator.validators.callback = {
+        html5Attributes: {
+            message: 'message',
+            callback: 'callback'
+        },
+
+        /**
+         * Return result from the callback method
+         *
+         * @param {BootstrapValidator} validator The validator plugin instance
+         * @param {jQuery} $field Field element
+         * @param {Object} options Can consist of the following keys:
+         * - callback: The callback method that passes 2 parameters:
+         *      callback: function(fieldValue, validator, $field) {
+         *          // fieldValue is the value of field
+         *          // validator is instance of BootstrapValidator
+         *          // $field is the field element
+         *      }
+         * - message: The invalid message
+         * @returns {Boolean|Deferred}
+         */
+        validate: function(validator, $field, options) {
+            var value = $field.val();
+
+            if (options.callback) {
+                var dfd      = new $.Deferred(),
+                    response = $.fn.bootstrapValidator.helpers.call(options.callback, [value, validator, $field]);
+                dfd.resolve($field, 'callback', 'boolean' === typeof response ? response : response.valid, 'object' === typeof response && response.message ? response.message : null);
+                return dfd;
+            }
+
+            return true;
+        }
+    };
+}(window.jQuery));
+;(function($) {
+    $.fn.bootstrapValidator.i18n.choice = $.extend($.fn.bootstrapValidator.i18n.choice || {}, {
+        'default': 'Please enter a valid value',
+        less: 'Please choose %s options at minimum',
+        more: 'Please choose %s options at maximum',
+        between: 'Please choose %s - %s options'
+    });
+
+    $.fn.bootstrapValidator.validators.choice = {
+        html5Attributes: {
+            message: 'message',
+            min: 'min',
+            max: 'max'
+        },
+
+        /**
+         * Check if the number of checked boxes are less or more than a given number
+         *
+         * @param {BootstrapValidator} validator The validator plugin instance
+         * @param {jQuery} $field Field element
+         * @param {Object} options Consists of following keys:
+         * - min
+         * - max
+         *
+         * At least one of two keys is required
+         * The min, max keys define the number which the field value compares to. min, max can be
+         *      - A number
+         *      - Name of field which its value defines the number
+         *      - Name of callback function that returns the number
+         *      - A callback function that returns the number
+         *
+         * - message: The invalid message
+         * @returns {Object}
+         */
+        validate: function(validator, $field, options) {
+            var numChoices = $field.is('select')
+                            ? validator.getFieldElements($field.attr('data-bv-field')).find('option').filter(':selected').length
+                            : validator.getFieldElements($field.attr('data-bv-field')).filter(':checked').length,
+                min        = options.min ? ($.isNumeric(options.min) ? options.min : validator.getDynamicOption($field, options.min)) : null,
+                max        = options.max ? ($.isNumeric(options.max) ? options.max : validator.getDynamicOption($field, options.max)) : null,
+                isValid    = true,
+                message    = options.message || $.fn.bootstrapValidator.i18n.choice['default'];
+
+            if ((min && numChoices < parseInt(min, 10)) || (max && numChoices > parseInt(max, 10))) {
+                isValid = false;
+            }
+
+            switch (true) {
+                case (!!min && !!max):
+                    message = $.fn.bootstrapValidator.helpers.format(options.message || $.fn.bootstrapValidator.i18n.choice.between, [parseInt(min, 10), parseInt(max, 10)]);
+                    break;
+
+                case (!!min):
+                    message = $.fn.bootstrapValidator.helpers.format(options.message || $.fn.bootstrapValidator.i18n.choice.less, parseInt(min, 10));
+                    break;
+
+                case (!!max):
+                    message = $.fn.bootstrapValidator.helpers.format(options.message || $.fn.bootstrapValidator.i18n.choice.more, parseInt(max, 10));
+                    break;
+
+                default:
+                    break;
+            }
+
+            return { valid: isValid, message: message };
+        }
+    };
+}(window.jQuery));
+;(function($) {
+    $.fn.bootstrapValidator.i18n.creditCard = $.extend($.fn.bootstrapValidator.i18n.creditCard || {}, {
+        'default': 'Please enter a valid credit card number'
+    });
+
+    $.fn.bootstrapValidator.validators.creditCard = {
+        /**
+         * Return true if the input value is valid credit card number
+         * Based on https://gist.github.com/DiegoSalazar/4075533
+         *
+         * @param {BootstrapValidator} validator The validator plugin instance
+         * @param {jQuery} $field Field element
+         * @param {Object} [options] Can consist of the following key:
+         * - message: The invalid message
+         * @returns {Boolean}
+         */
+        validate: function(validator, $field, options) {
+            var value = $field.val();
+            if (value === '') {
+                return true;
+            }
+
+            // Accept only digits, dashes or spaces
+            if (/[^0-9-\s]+/.test(value)) {
+                return false;
+            }
+            value = value.replace(/\D/g, '');
+
+            if (!$.fn.bootstrapValidator.helpers.luhn(value)) {
+                return false;
+            }
+
+            // Validate the card number based on prefix (IIN ranges) and length
+            var cards = {
+                AMERICAN_EXPRESS: {
+                    length: [15],
+                    prefix: ['34', '37']
+                },
+                DINERS_CLUB: {
+                    length: [14],
+                    prefix: ['300', '301', '302', '303', '304', '305', '36']
+                },
+                DINERS_CLUB_US: {
+                    length: [16],
+                    prefix: ['54', '55']
+                },
+                DISCOVER: {
+                    length: [16],
+                    prefix: ['6011', '622126', '622127', '622128', '622129', '62213',
+                             '62214', '62215', '62216', '62217', '62218', '62219',
+                             '6222', '6223', '6224', '6225', '6226', '6227', '6228',
+                             '62290', '62291', '622920', '622921', '622922', '622923',
+                             '622924', '622925', '644', '645', '646', '647', '648',
+                             '649', '65']
+                },
+                JCB: {
+                    length: [16],
+                    prefix: ['3528', '3529', '353', '354', '355', '356', '357', '358']
+                },
+                LASER: {
+                    length: [16, 17, 18, 19],
+                    prefix: ['6304', '6706', '6771', '6709']
+                },
+                MAESTRO: {
+                    length: [12, 13, 14, 15, 16, 17, 18, 19],
+                    prefix: ['5018', '5020', '5038', '6304', '6759', '6761', '6762', '6763', '6764', '6765', '6766']
+                },
+                MASTERCARD: {
+                    length: [16],
+                    prefix: ['51', '52', '53', '54', '55']
+                },
+                SOLO: {
+                    length: [16, 18, 19],
+                    prefix: ['6334', '6767']
+                },
+                UNIONPAY: {
+                    length: [16, 17, 18, 19],
+                    prefix: ['622126', '622127', '622128', '622129', '62213', '62214',
+                             '62215', '62216', '62217', '62218', '62219', '6222', '6223',
+                             '6224', '6225', '6226', '6227', '6228', '62290', '62291',
+                             '622920', '622921', '622922', '622923', '622924', '622925']
+                },
+                VISA: {
+                    length: [16],
+                    prefix: ['4']
+                }
+            };
+
+            var type, i;
+            for (type in cards) {
+                for (i in cards[type].prefix) {
+                    if (value.substr(0, cards[type].prefix[i].length) === cards[type].prefix[i]     // Check the prefix
+                        && $.inArray(value.length, cards[type].length) !== -1)                      // and length
+                    {
+                        return true;
+                    }
+                }
+            }
+
+            return false;
+        }
+    };
+}(window.jQuery));
+;(function($) {
+    $.fn.bootstrapValidator.i18n.cusip = $.extend($.fn.bootstrapValidator.i18n.cusip || {}, {
+        'default': 'Please enter a valid CUSIP number'
+    });
+
+    $.fn.bootstrapValidator.validators.cusip = {
+        /**
+         * Validate a CUSIP
+         * Examples:
+         * - Valid: 037833100, 931142103, 14149YAR8, 126650BG6
+         * - Invalid: 31430F200, 022615AC2
+         *
+         * @see http://en.wikipedia.org/wiki/CUSIP
+         * @param {BootstrapValidator} validator The validator plugin instance
+         * @param {jQuery} $field Field element
+         * @param {Object} [options] Can consist of the following keys:
+         * - message: The invalid message
+         * @returns {Boolean}
+         */
+        validate: function(validator, $field, options) {
+            var value = $field.val();
+            if (value === '') {
+                return true;
+            }
+
+            value = value.toUpperCase();
+            if (!/^[0-9A-Z]{9}$/.test(value)) {
+                return false;
+            }
+
+            var converted = $.map(value.split(''), function(item) {
+                                var code = item.charCodeAt(0);
+                                return (code >= 'A'.charCodeAt(0) && code <= 'Z'.charCodeAt(0))
+                                            // Replace A, B, C, ..., Z with 10, 11, ..., 35
+                                            ? (code - 'A'.charCodeAt(0) + 10)
+                                            : item;
+                            }),
+                length    = converted.length,
+                sum       = 0;
+            for (var i = 0; i < length - 1; i++) {
+                var num = parseInt(converted[i], 10);
+                if (i % 2 !== 0) {
+                    num *= 2;
+                }
+                if (num > 9) {
+                    num -= 9;
+                }
+                sum += num;
+            }
+
+            sum = (10 - (sum % 10)) % 10;
+            return sum === converted[length - 1];
+        }
+    };
+}(window.jQuery));
+;(function($) {
+    $.fn.bootstrapValidator.i18n.cvv = $.extend($.fn.bootstrapValidator.i18n.cvv || {}, {
+        'default': 'Please enter a valid CVV number'
+    });
+
+    $.fn.bootstrapValidator.validators.cvv = {
+        html5Attributes: {
+            message: 'message',
+            ccfield: 'creditCardField'
+        },
+
+        /**
+         * Return true if the input value is a valid CVV number.
+         *
+         * @param {BootstrapValidator} validator The validator plugin instance
+         * @param {jQuery} $field Field element
+         * @param {Object} options Can consist of the following keys:
+         * - creditCardField: The credit card number field. It can be null
+         * - message: The invalid message
+         * @returns {Boolean}
+         */
+        validate: function(validator, $field, options) {
+            var value = $field.val();
+            if (value === '') {
+                return true;
+            }
+
+            if (!/^[0-9]{3,4}$/.test(value)) {
+                return false;
+            }
+
+            if (!options.creditCardField) {
+                return true;
+            }
+
+            // Get the credit card number
+            var creditCard = validator.getFieldElements(options.creditCardField).val();
+            if (creditCard === '') {
+                return true;
+            }
+            
+            creditCard = creditCard.replace(/\D/g, '');
+
+            // Supported credit card types
+            var cards = {
+                AMERICAN_EXPRESS: {
+                    length: [15],
+                    prefix: ['34', '37']
+                },
+                DINERS_CLUB: {
+                    length: [14],
+                    prefix: ['300', '301', '302', '303', '304', '305', '36']
+                },
+                DINERS_CLUB_US: {
+                    length: [16],
+                    prefix: ['54', '55']
+                },
+                DISCOVER: {
+                    length: [16],
+                    prefix: ['6011', '622126', '622127', '622128', '622129', '62213',
+                             '62214', '62215', '62216', '62217', '62218', '62219',
+                             '6222', '6223', '6224', '6225', '6226', '6227', '6228',
+                             '62290', '62291', '622920', '622921', '622922', '622923',
+                             '622924', '622925', '644', '645', '646', '647', '648',
+                             '649', '65']
+                },
+                JCB: {
+                    length: [16],
+                    prefix: ['3528', '3529', '353', '354', '355', '356', '357', '358']
+                },
+                LASER: {
+                    length: [16, 17, 18, 19],
+                    prefix: ['6304', '6706', '6771', '6709']
+                },
+                MAESTRO: {
+                    length: [12, 13, 14, 15, 16, 17, 18, 19],
+                    prefix: ['5018', '5020', '5038', '6304', '6759', '6761', '6762', '6763', '6764', '6765', '6766']
+                },
+                MASTERCARD: {
+                    length: [16],
+                    prefix: ['51', '52', '53', '54', '55']
+                },
+                SOLO: {
+                    length: [16, 18, 19],
+                    prefix: ['6334', '6767']
+                },
+                UNIONPAY: {
+                    length: [16, 17, 18, 19],
+                    prefix: ['622126', '622127', '622128', '622129', '62213', '62214',
+                             '62215', '62216', '62217', '62218', '62219', '6222', '6223',
+                             '6224', '6225', '6226', '6227', '6228', '62290', '62291',
+                             '622920', '622921', '622922', '622923', '622924', '622925']
+                },
+                VISA: {
+                    length: [16],
+                    prefix: ['4']
+                }
+            };
+            var type, i, creditCardType = null;
+            for (type in cards) {
+                for (i in cards[type].prefix) {
+                    if (creditCard.substr(0, cards[type].prefix[i].length) === cards[type].prefix[i]    // Check the prefix
+                        && $.inArray(creditCard.length, cards[type].length) !== -1)                     // and length
+                    {
+                        creditCardType = type;
+                        break;
+                    }
+                }
+            }
+
+            return (creditCardType === null)
+                        ? false
+                        : (('AMERICAN_EXPRESS' === creditCardType) ? (value.length === 4) : (value.length === 3));
+        }
+    };
+}(window.jQuery));
+;(function($) {
+    $.fn.bootstrapValidator.i18n.date = $.extend($.fn.bootstrapValidator.i18n.date || {}, {
+        'default': 'Please enter a valid date'
+    });
+
+    $.fn.bootstrapValidator.validators.date = {
+        html5Attributes: {
+            message: 'message',
+            format: 'format',
+            separator: 'separator'
+        },
+
+        /**
+         * Return true if the input value is valid date
+         *
+         * @param {BootstrapValidator} validator The validator plugin instance
+         * @param {jQuery} $field Field element
+         * @param {Object} options Can consist of the following keys:
+         * - message: The invalid message
+         * - separator: Use to separate the date, month, and year.
+         * By default, it is /
+         * - format: The date format. Default is MM/DD/YYYY
+         * The format can be:
+         *
+         * i) date: Consist of DD, MM, YYYY parts which are separated by the separator option
+         * ii) date and time:
+         * The time can consist of h, m, s parts which are separated by :
+         * ii) date, time and A (indicating AM or PM)
+         * @returns {Boolean}
+         */
+        validate: function(validator, $field, options) {
+            var value = $field.val();
+            if (value === '') {
+                return true;
+            }
+
+            options.format = options.format || 'MM/DD/YYYY';
+
+            var formats    = options.format.split(' '),
+                dateFormat = formats[0],
+                timeFormat = (formats.length > 1) ? formats[1] : null,
+                amOrPm     = (formats.length > 2) ? formats[2] : null,
+                sections   = value.split(' '),
+                date       = sections[0],
+                time       = (sections.length > 1) ? sections[1] : null;
+
+            if (formats.length !== sections.length) {
+                return false;
+            }
+
+            // Determine the separator
+            var separator = options.separator;
+            if (!separator) {
+                separator = (date.indexOf('/') !== -1) ? '/' : ((date.indexOf('-') !== -1) ? '-' : null);
+            }
+            if (separator === null || date.indexOf(separator) === -1) {
+                return false;
+            }
+
+            // Determine the date
+            date       = date.split(separator);
+            dateFormat = dateFormat.split(separator);
+            if (date.length !== dateFormat.length) {
+                return false;
+            }
+
+            var year  = date[$.inArray('YYYY', dateFormat)],
+                month = date[$.inArray('MM', dateFormat)],
+                day   = date[$.inArray('DD', dateFormat)];
+
+            if (!year || !month || !day) {
+                return false;
+            }
+
+            // Determine the time
+            var minutes = null, hours = null, seconds = null;
+            if (timeFormat) {
+                timeFormat = timeFormat.split(':');
+                time       = time.split(':');
+
+                if (timeFormat.length !== time.length) {
+                    return false;
+                }
+
+                hours   = time.length > 0 ? time[0] : null;
+                minutes = time.length > 1 ? time[1] : null;
+                seconds = time.length > 2 ? time[2] : null;
+
+                // Validate seconds
+                if (seconds) {
+                    seconds = parseInt(seconds, 10);
+                    if (isNaN(seconds) || seconds < 0 || seconds > 60) {
+                        return false;
+                    }
+                }
+
+                // Validate hours
+                if (hours) {
+                    hours = parseInt(hours, 10);
+                    if (isNaN(hours) || hours < 0 || hours >= 24 || (amOrPm && hours > 12)) {
+                        return false;
+                    }
+                }
+
+                // Validate minutes
+                if (minutes) {
+                    minutes = parseInt(minutes, 10);
+                    if (isNaN(minutes) || minutes < 0 || minutes > 59) {
+                        return false;
+                    }
+                }
+            }
+
+            // Validate day, month, and year
+            return $.fn.bootstrapValidator.helpers.date(year, month, day);
+        }
+    };
+}(window.jQuery));
+;(function($) {
+    $.fn.bootstrapValidator.i18n.different = $.extend($.fn.bootstrapValidator.i18n.different || {}, {
+        'default': 'Please enter a different value'
+    });
+
+    $.fn.bootstrapValidator.validators.different = {
+        html5Attributes: {
+            message: 'message',
+            field: 'field'
+        },
+
+        /**
+         * Return true if the input value is different with given field's value
+         *
+         * @param {BootstrapValidator} validator The validator plugin instance
+         * @param {jQuery} $field Field element
+         * @param {Object} options Consists of the following key:
+         * - field: The name of field that will be used to compare with current one
+         * - message: The invalid message
+         * @returns {Boolean}
+         */
+        validate: function(validator, $field, options) {
+            var value = $field.val();
+            if (value === '') {
+                return true;
+            }
+
+            var compareWith = validator.getFieldElements(options.field);
+            if (compareWith === null) {
+                return true;
+            }
+
+            if (value !== compareWith.val()) {
+                validator.updateStatus(options.field, validator.STATUS_VALID, 'different');
+                return true;
+            } else {
+                return false;
+            }
+        }
+    };
+}(window.jQuery));
+;(function($) {
+    $.fn.bootstrapValidator.i18n.digits = $.extend($.fn.bootstrapValidator.i18n.digits || {}, {
+        'default': 'Please enter only digits'
+    });
+
+    $.fn.bootstrapValidator.validators.digits = {
+        /**
+         * Return true if the input value contains digits only
+         *
+         * @param {BootstrapValidator} validator Validate plugin instance
+         * @param {jQuery} $field Field element
+         * @param {Object} [options]
+         * @returns {Boolean}
+         */
+        validate: function(validator, $field, options) {
+            var value = $field.val();
+            if (value === '') {
+                return true;
+            }
+
+            return /^\d+$/.test(value);
+        }
+    };
+}(window.jQuery));
+;(function($) {
+    $.fn.bootstrapValidator.i18n.ean = $.extend($.fn.bootstrapValidator.i18n.ean || {}, {
+        'default': 'Please enter a valid EAN number'
+    });
+
+    $.fn.bootstrapValidator.validators.ean = {
+        /**
+         * Validate EAN (International Article Number)
+         * Examples:
+         * - Valid: 73513537, 9780471117094, 4006381333931
+         * - Invalid: 73513536
+         *
+         * @see http://en.wikipedia.org/wiki/European_Article_Number
+         * @param {BootstrapValidator} validator The validator plugin instance
+         * @param {jQuery} $field Field element
+         * @param {Object} options Can consist of the following keys:
+         * - message: The invalid message
+         * @returns {Boolean}
+         */
+        validate: function(validator, $field, options) {
+            var value = $field.val();
+            if (value === '') {
+                return true;
+            }
+
+            if (!/^(\d{8}|\d{12}|\d{13})$/.test(value)) {
+                return false;
+            }
+
+            var length = value.length,
+                sum    = 0,
+                weight = (length === 8) ? [3, 1] : [1, 3];
+            for (var i = 0; i < length - 1; i++) {
+                sum += parseInt(value.charAt(i), 10) * weight[i % 2];
+            }
+            sum = (10 - sum % 10) % 10;
+            return (sum + '' === value.charAt(length - 1));
+        }
+    };
+}(window.jQuery));
+;(function($) {
+    $.fn.bootstrapValidator.i18n.emailAddress = $.extend($.fn.bootstrapValidator.i18n.emailAddress || {}, {
+        'default': 'Please enter a valid email address'
+    });
+
+    $.fn.bootstrapValidator.validators.emailAddress = {
+        enableByHtml5: function($field) {
+            return ('email' === $field.attr('type'));
+        },
+
+        /**
+         * Return true if and only if the input value is a valid email address
+         *
+         * @param {BootstrapValidator} validator Validate plugin instance
+         * @param {jQuery} $field Field element
+         * @param {Object} [options]
+         * @returns {Boolean}
+         */
+        validate: function(validator, $field, options) {
+            var value = $field.val();
+            if (value === '') {
+                return true;
+            }
+
+            // Email address regular expression
+            // http://stackoverflow.com/questions/46155/validate-email-address-in-javascript
+            var emailRegExp = /^(([^<>()[\]\\.,;:\s@\"]+(\.[^<>()[\]\\.,;:\s@\"]+)*)|(\".+\"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/;
+            return emailRegExp.test(value);
+        }
+    };
+}(window.jQuery));
+;(function($) {
+    $.fn.bootstrapValidator.i18n.file = $.extend($.fn.bootstrapValidator.i18n.file || {}, {
+        'default': 'Please choose a valid file'
+    });
+
+    $.fn.bootstrapValidator.validators.file = {
+        html5Attributes: {
+            extension: 'extension',
+            maxsize: 'maxSize',
+            message: 'message',
+            type: 'type'
+        },
+
+        /**
+         * Validate upload file. Use HTML 5 API if the browser supports
+         *
+         * @param {BootstrapValidator} validator The validator plugin instance
+         * @param {jQuery} $field Field element
+         * @param {Object} options Can consist of the following keys:
+         * - extension: The allowed extensions, separated by a comma
+         * - maxSize: The maximum size in bytes
+         * - message: The invalid message
+         * - type: The allowed MIME type, separated by a comma
+         * @returns {Boolean}
+         */
+        validate: function(validator, $field, options) {
+            var value = $field.val();
+            if (value === '') {
+                return true;
+            }
+
+            var ext,
+                extensions = options.extension ? options.extension.toLowerCase().split(',') : null,
+                types      = options.type      ? options.type.toLowerCase().split(',')      : null,
+                html5      = (window.File && window.FileList && window.FileReader);
+
+            if (html5) {
+                // Get FileList instance
+                var files = $field.get(0).files,
+                    total = files.length;
+                for (var i = 0; i < total; i++) {
+                    // Check file size
+                    if (options.maxSize && files[i].size > parseInt(options.maxSize, 10)) {
+                        return false;
+                    }
+
+                    // Check file extension
+                    ext = files[i].name.substr(files[i].name.lastIndexOf('.') + 1);
+                    if (extensions && $.inArray(ext.toLowerCase(), extensions) === -1) {
+                        return false;
+                    }
+
+                    // Check file type
+                    if (types && $.inArray(files[i].type.toLowerCase(), types) === -1) {
+                        return false;
+                    }
+                }
+            } else {
+                // Check file extension
+                ext = value.substr(value.lastIndexOf('.') + 1);
+                if (extensions && $.inArray(ext.toLowerCase(), extensions) === -1) {
+                    return false;
+                }
+            }
+
+            return true;
+        }
+    };
+}(window.jQuery));
+;(function($) {
+    $.fn.bootstrapValidator.i18n.greaterThan = $.extend($.fn.bootstrapValidator.i18n.greaterThan || {}, {
+        'default': 'Please enter a value greater than or equal to %s',
+        notInclusive: 'Please enter a value greater than %s'
+    });
+
+    $.fn.bootstrapValidator.validators.greaterThan = {
+        html5Attributes: {
+            message: 'message',
+            value: 'value',
+            inclusive: 'inclusive'
+        },
+
+        enableByHtml5: function($field) {
+            var min = $field.attr('min');
+            if (min) {
+                return {
+                    value: min
+                };
+            }
+
+            return false;
+        },
+
+        /**
+         * Return true if the input value is greater than or equals to given number
+         *
+         * @param {BootstrapValidator} validator Validate plugin instance
+         * @param {jQuery} $field Field element
+         * @param {Object} options Can consist of the following keys:
+         * - value: Define the number to compare with. It can be
+         *      - A number
+         *      - Name of field which its value defines the number
+         *      - Name of callback function that returns the number
+         *      - A callback function that returns the number
+         *
+         * - inclusive [optional]: Can be true or false. Default is true
+         * - message: The invalid message
+         * @returns {Boolean|Object}
+         */
+        validate: function(validator, $field, options) {
+            var value = $field.val();
+            if (value === '') {
+                return true;
+            }
+
+            var compareTo = $.isNumeric(options.value) ? options.value : validator.getDynamicOption($field, options.value);
+
+            value = parseFloat(value);
+			return (options.inclusive === true || options.inclusive === undefined)
+                    ? {
+                        valid: value >= compareTo,
+                        message: $.fn.bootstrapValidator.helpers.format(options.message || $.fn.bootstrapValidator.i18n.greaterThan['default'], compareTo)
+                    }
+                    : {
+                        valid: value > compareTo,
+                        message: $.fn.bootstrapValidator.helpers.format(options.message || $.fn.bootstrapValidator.i18n.greaterThan.notInclusive, compareTo)
+                    };
+        }
+    };
+}(window.jQuery));
+;(function($) {
+    $.fn.bootstrapValidator.i18n.grid = $.extend($.fn.bootstrapValidator.i18n.grid || {}, {
+        'default': 'Please enter a valid GRId number'
+    });
+
+    $.fn.bootstrapValidator.validators.grid = {
+        /**
+         * Validate GRId (Global Release Identifier)
+         * Examples:
+         * - Valid: A12425GABC1234002M, A1-2425G-ABC1234002-M, A1 2425G ABC1234002 M, Grid:A1-2425G-ABC1234002-M
+         * - Invalid: A1-2425G-ABC1234002-Q
+         *
+         * @see http://en.wikipedia.org/wiki/Global_Release_Identifier
+         * @param {BootstrapValidator} validator The validator plugin instance
+         * @param {jQuery} $field Field element
+         * @param {Object} options Can consist of the following keys:
+         * - message: The invalid message
+         * @returns {Boolean}
+         */
+        validate: function(validator, $field, options) {
+            var value = $field.val();
+            if (value === '') {
+                return true;
+            }
+
+            value = value.toUpperCase();
+            if (!/^[GRID:]*([0-9A-Z]{2})[-\s]*([0-9A-Z]{5})[-\s]*([0-9A-Z]{10})[-\s]*([0-9A-Z]{1})$/g.test(value)) {
+                return false;
+            }
+            value = value.replace(/\s/g, '').replace(/-/g, '');
+            if ('GRID:' === value.substr(0, 5)) {
+                value = value.substr(5);
+            }
+            return $.fn.bootstrapValidator.helpers.mod37And36(value);
+        }
+    };
+}(window.jQuery));
+;(function($) {
+    $.fn.bootstrapValidator.i18n.hex = $.extend($.fn.bootstrapValidator.i18n.hex || {}, {
+        'default': 'Please enter a valid hexadecimal number'
+    });
+
+    $.fn.bootstrapValidator.validators.hex = {
+        /**
+         * Return true if and only if the input value is a valid hexadecimal number
+         *
+         * @param {BootstrapValidator} validator The validator plugin instance
+         * @param {jQuery} $field Field element
+         * @param {Object} options Consist of key:
+         * - message: The invalid message
+         * @returns {Boolean}
+         */
+        validate: function(validator, $field, options) {
+            var value = $field.val();
+            if (value === '') {
+                return true;
+            }
+
+            return /^[0-9a-fA-F]+$/.test(value);
+        }
+    };
+}(window.jQuery));
+;(function($) {
+    $.fn.bootstrapValidator.i18n.hexColor = $.extend($.fn.bootstrapValidator.i18n.hexColor || {}, {
+        'default': 'Please enter a valid hex color'
+    });
+
+    $.fn.bootstrapValidator.validators.hexColor = {
+        enableByHtml5: function($field) {
+            return ('color' === $field.attr('type'));
+        },
+
+        /**
+         * Return true if the input value is a valid hex color
+         *
+         * @param {BootstrapValidator} validator The validator plugin instance
+         * @param {jQuery} $field Field element
+         * @param {Object} options Can consist of the following keys:
+         * - message: The invalid message
+         * @returns {Boolean}
+         */
+        validate: function(validator, $field, options) {
+            var value = $field.val();
+            if (value === '') {
+                return true;
+            }
+            return /(^#[0-9A-F]{6}$)|(^#[0-9A-F]{3}$)/i.test(value);
+        }
+    };
+}(window.jQuery));
+;(function($) {
+    $.fn.bootstrapValidator.i18n.iban = $.extend($.fn.bootstrapValidator.i18n.iban || {}, {
+        'default': 'Please enter a valid IBAN number',
+        countryNotSupported: 'The country code %s is not supported',
+        country: 'Please enter a valid IBAN number in %s',
+        countries: {
+            AD: 'Andorra',
+            AE: 'United Arab Emirates',
+            AL: 'Albania',
+            AO: 'Angola',
+            AT: 'Austria',
+            AZ: 'Azerbaijan',
+            BA: 'Bosnia and Herzegovina',
+            BE: 'Belgium',
+            BF: 'Burkina Faso',
+            BG: 'Bulgaria',
+            BH: 'Bahrain',
+            BI: 'Burundi',
+            BJ: 'Benin',
+            BR: 'Brazil',
+            CH: 'Switzerland',
+            CI: 'Ivory Coast',
+            CM: 'Cameroon',
+            CR: 'Costa Rica',
+            CV: 'Cape Verde',
+            CY: 'Cyprus',
+            CZ: 'Czech Republic',
+            DE: 'Germany',
+            DK: 'Denmark',
+            DO: 'Dominican Republic',
+            DZ: 'Algeria',
+            EE: 'Estonia',
+            ES: 'Spain',
+            FI: 'Finland',
+            FO: 'Faroe Islands',
+            FR: 'France',
+            GB: 'United Kingdom',
+            GE: 'Georgia',
+            GI: 'Gibraltar',
+            GL: 'Greenland',
+            GR: 'Greece',
+            GT: 'Guatemala',
+            HR: 'Croatia',
+            HU: 'Hungary',
+            IE: 'Ireland',
+            IL: 'Israel',
+            IR: 'Iran',
+            IS: 'Iceland',
+            IT: 'Italy',
+            JO: 'Jordan',
+            KW: 'Kuwait',
+            KZ: 'Kazakhstan',
+            LB: 'Lebanon',
+            LI: 'Liechtenstein',
+            LT: 'Lithuania',
+            LU: 'Luxembourg',
+            LV: 'Latvia',
+            MC: 'Monaco',
+            MD: 'Moldova',
+            ME: 'Montenegro',
+            MG: 'Madagascar',
+            MK: 'Macedonia',
+            ML: 'Mali',
+            MR: 'Mauritania',
+            MT: 'Malta',
+            MU: 'Mauritius',
+            MZ: 'Mozambique',
+            NL: 'Netherlands',
+            NO: 'Norway',
+            PK: 'Pakistan',
+            PL: 'Poland',
+            PS: 'Palestinian',
+            PT: 'Portugal',
+            QA: 'Qatar',
+            RO: 'Romania',
+            RS: 'Serbia',
+            SA: 'Saudi Arabia',
+            SE: 'Sweden',
+            SI: 'Slovenia',
+            SK: 'Slovakia',
+            SM: 'San Marino',
+            SN: 'Senegal',
+            TN: 'Tunisia',
+            TR: 'Turkey',
+            VG: 'Virgin Islands, British'
+        }
+    });
+
+    $.fn.bootstrapValidator.validators.iban = {
+        html5Attributes: {
+            message: 'message',
+            country: 'country'
+        },
+
+        // http://www.swift.com/dsp/resources/documents/IBAN_Registry.pdf
+        // http://en.wikipedia.org/wiki/International_Bank_Account_Number#IBAN_formats_by_country
+        REGEX: {
+            'AD': 'AD[0-9]{2}[0-9]{4}[0-9]{4}[A-Z0-9]{12}',                     // Andorra
+            'AE': 'AE[0-9]{2}[0-9]{3}[0-9]{16}',                                // United Arab Emirates
+            'AL': 'AL[0-9]{2}[0-9]{8}[A-Z0-9]{16}',                             // Albania
+            'AO': 'AO[0-9]{2}[0-9]{21}',                                        // Angola
+            'AT': 'AT[0-9]{2}[0-9]{5}[0-9]{11}',                                // Austria
+            'AZ': 'AZ[0-9]{2}[A-Z]{4}[A-Z0-9]{20}',                             // Azerbaijan
+            'BA': 'BA[0-9]{2}[0-9]{3}[0-9]{3}[0-9]{8}[0-9]{2}',                 // Bosnia and Herzegovina
+            'BE': 'BE[0-9]{2}[0-9]{3}[0-9]{7}[0-9]{2}',                         // Belgium
+            'BF': 'BF[0-9]{2}[0-9]{23}',                                        // Burkina Faso
+            'BG': 'BG[0-9]{2}[A-Z]{4}[0-9]{4}[0-9]{2}[A-Z0-9]{8}',              // Bulgaria
+            'BH': 'BH[0-9]{2}[A-Z]{4}[A-Z0-9]{14}',                             // Bahrain
+            'BI': 'BI[0-9]{2}[0-9]{12}',                                        // Burundi
+            'BJ': 'BJ[0-9]{2}[A-Z]{1}[0-9]{23}',                                // Benin
+            'BR': 'BR[0-9]{2}[0-9]{8}[0-9]{5}[0-9]{10}[A-Z][A-Z0-9]',           // Brazil
+            'CH': 'CH[0-9]{2}[0-9]{5}[A-Z0-9]{12}',                             // Switzerland
+            'CI': 'CI[0-9]{2}[A-Z]{1}[0-9]{23}',                                // Ivory Coast
+            'CM': 'CM[0-9]{2}[0-9]{23}',                                        // Cameroon
+            'CR': 'CR[0-9]{2}[0-9]{3}[0-9]{14}',                                // Costa Rica
+            'CV': 'CV[0-9]{2}[0-9]{21}',                                        // Cape Verde
+            'CY': 'CY[0-9]{2}[0-9]{3}[0-9]{5}[A-Z0-9]{16}',                     // Cyprus
+            'CZ': 'CZ[0-9]{2}[0-9]{20}',                                        // Czech Republic
+            'DE': 'DE[0-9]{2}[0-9]{8}[0-9]{10}',                                // Germany
+            'DK': 'DK[0-9]{2}[0-9]{14}',                                        // Denmark
+            'DO': 'DO[0-9]{2}[A-Z0-9]{4}[0-9]{20}',                             // Dominican Republic
+            'DZ': 'DZ[0-9]{2}[0-9]{20}',                                        // Algeria
+            'EE': 'EE[0-9]{2}[0-9]{2}[0-9]{2}[0-9]{11}[0-9]{1}',                // Estonia
+            'ES': 'ES[0-9]{2}[0-9]{4}[0-9]{4}[0-9]{1}[0-9]{1}[0-9]{10}',        // Spain
+            'FI': 'FI[0-9]{2}[0-9]{6}[0-9]{7}[0-9]{1}',                         // Finland
+            'FO': 'FO[0-9]{2}[0-9]{4}[0-9]{9}[0-9]{1}',                         // Faroe Islands
+            'FR': 'FR[0-9]{2}[0-9]{5}[0-9]{5}[A-Z0-9]{11}[0-9]{2}',             // France
+            'GB': 'GB[0-9]{2}[A-Z]{4}[0-9]{6}[0-9]{8}',                         // United Kingdom
+            'GE': 'GE[0-9]{2}[A-Z]{2}[0-9]{16}',                                // Georgia
+            'GI': 'GI[0-9]{2}[A-Z]{4}[A-Z0-9]{15}',                             // Gibraltar
+            'GL': 'GL[0-9]{2}[0-9]{4}[0-9]{9}[0-9]{1}',                         // Greenland
+            'GR': 'GR[0-9]{2}[0-9]{3}[0-9]{4}[A-Z0-9]{16}',                     // Greece
+            'GT': 'GT[0-9]{2}[A-Z0-9]{4}[A-Z0-9]{20}',                          // Guatemala
+            'HR': 'HR[0-9]{2}[0-9]{7}[0-9]{10}',                                // Croatia
+            'HU': 'HU[0-9]{2}[0-9]{3}[0-9]{4}[0-9]{1}[0-9]{15}[0-9]{1}',        // Hungary
+            'IE': 'IE[0-9]{2}[A-Z]{4}[0-9]{6}[0-9]{8}',                         // Ireland
+            'IL': 'IL[0-9]{2}[0-9]{3}[0-9]{3}[0-9]{13}',                        // Israel
+            'IR': 'IR[0-9]{2}[0-9]{22}',                                        // Iran
+            'IS': 'IS[0-9]{2}[0-9]{4}[0-9]{2}[0-9]{6}[0-9]{10}',                // Iceland
+            'IT': 'IT[0-9]{2}[A-Z]{1}[0-9]{5}[0-9]{5}[A-Z0-9]{12}',             // Italy
+            'JO': 'JO[0-9]{2}[A-Z]{4}[0-9]{4}[0]{8}[A-Z0-9]{10}',               // Jordan
+            'KW': 'KW[0-9]{2}[A-Z]{4}[0-9]{22}',                                // Kuwait
+            'KZ': 'KZ[0-9]{2}[0-9]{3}[A-Z0-9]{13}',                             // Kazakhstan
+            'LB': 'LB[0-9]{2}[0-9]{4}[A-Z0-9]{20}',                             // Lebanon
+            'LI': 'LI[0-9]{2}[0-9]{5}[A-Z0-9]{12}',                             // Liechtenstein
+            'LT': 'LT[0-9]{2}[0-9]{5}[0-9]{11}',                                // Lithuania
+            'LU': 'LU[0-9]{2}[0-9]{3}[A-Z0-9]{13}',                             // Luxembourg
+            'LV': 'LV[0-9]{2}[A-Z]{4}[A-Z0-9]{13}',                             // Latvia
+            'MC': 'MC[0-9]{2}[0-9]{5}[0-9]{5}[A-Z0-9]{11}[0-9]{2}',             // Monaco
+            'MD': 'MD[0-9]{2}[A-Z0-9]{20}',                                     // Moldova
+            'ME': 'ME[0-9]{2}[0-9]{3}[0-9]{13}[0-9]{2}',                        // Montenegro
+            'MG': 'MG[0-9]{2}[0-9]{23}',                                        // Madagascar
+            'MK': 'MK[0-9]{2}[0-9]{3}[A-Z0-9]{10}[0-9]{2}',                     // Macedonia
+            'ML': 'ML[0-9]{2}[A-Z]{1}[0-9]{23}',                                // Mali
+            'MR': 'MR13[0-9]{5}[0-9]{5}[0-9]{11}[0-9]{2}',                      // Mauritania
+            'MT': 'MT[0-9]{2}[A-Z]{4}[0-9]{5}[A-Z0-9]{18}',                     // Malta
+            'MU': 'MU[0-9]{2}[A-Z]{4}[0-9]{2}[0-9]{2}[0-9]{12}[0-9]{3}[A-Z]{3}',// Mauritius
+            'MZ': 'MZ[0-9]{2}[0-9]{21}',                                        // Mozambique
+            'NL': 'NL[0-9]{2}[A-Z]{4}[0-9]{10}',                                // Netherlands
+            'NO': 'NO[0-9]{2}[0-9]{4}[0-9]{6}[0-9]{1}',                         // Norway
+            'PK': 'PK[0-9]{2}[A-Z]{4}[A-Z0-9]{16}',                             // Pakistan
+            'PL': 'PL[0-9]{2}[0-9]{8}[0-9]{16}',                                // Poland
+            'PS': 'PS[0-9]{2}[A-Z]{4}[A-Z0-9]{21}',                             // Palestinian
+            'PT': 'PT[0-9]{2}[0-9]{4}[0-9]{4}[0-9]{11}[0-9]{2}',                // Portugal
+            'QA': 'QA[0-9]{2}[A-Z]{4}[A-Z0-9]{21}',                             // Qatar
+            'RO': 'RO[0-9]{2}[A-Z]{4}[A-Z0-9]{16}',                             // Romania
+            'RS': 'RS[0-9]{2}[0-9]{3}[0-9]{13}[0-9]{2}',                        // Serbia
+            'SA': 'SA[0-9]{2}[0-9]{2}[A-Z0-9]{18}',                             // Saudi Arabia
+            'SE': 'SE[0-9]{2}[0-9]{3}[0-9]{16}[0-9]{1}',                        // Sweden
+            'SI': 'SI[0-9]{2}[0-9]{5}[0-9]{8}[0-9]{2}',                         // Slovenia
+            'SK': 'SK[0-9]{2}[0-9]{4}[0-9]{6}[0-9]{10}',                        // Slovakia
+            'SM': 'SM[0-9]{2}[A-Z]{1}[0-9]{5}[0-9]{5}[A-Z0-9]{12}',             // San Marino
+            'SN': 'SN[0-9]{2}[A-Z]{1}[0-9]{23}',                                // Senegal
+            'TN': 'TN59[0-9]{2}[0-9]{3}[0-9]{13}[0-9]{2}',                      // Tunisia
+            'TR': 'TR[0-9]{2}[0-9]{5}[A-Z0-9]{1}[A-Z0-9]{16}',                  // Turkey
+            'VG': 'VG[0-9]{2}[A-Z]{4}[0-9]{16}'                                 // Virgin Islands, British
+        },
+
+        /**
+         * Validate an International Bank Account Number (IBAN)
+         * To test it, take the sample IBAN from
+         * http://www.nordea.com/Our+services/International+products+and+services/Cash+Management/IBAN+countries/908462.html
+         *
+         * @param {BootstrapValidator} validator The validator plugin instance
+         * @param {jQuery} $field Field element
+         * @param {Object} options Can consist of the following keys:
+         * - message: The invalid message
+         * - country: The ISO 3166-1 country code. It can be
+         *      - A country code
+         *      - Name of field which its value defines the country code
+         *      - Name of callback function that returns the country code
+         *      - A callback function that returns the country code
+         * @returns {Boolean|Object}
+         */
+        validate: function(validator, $field, options) {
+            var value = $field.val();
+            if (value === '') {
+                return true;
+            }
+
+            value = value.replace(/[^a-zA-Z0-9]/g, '').toUpperCase();
+            var country = options.country;
+            if (!country) {
+                country = value.substr(0, 2);
+            } else if (typeof country !== 'string' || !this.REGEX[country]) {
+                // Determine the country code
+                country = validator.getDynamicOption($field, country);
+            }
+
+            if (!this.REGEX[country]) {
+                return {
+                    valid: false,
+                    message: $.fn.bootstrapValidator.helpers.format($.fn.bootstrapValidator.i18n.iban.countryNotSupported, country)
+                };
+            }
+
+            if (!(new RegExp('^' + this.REGEX[country] + '$')).test(value)) {
+                return {
+                    valid: false,
+                    message: $.fn.bootstrapValidator.helpers.format(options.message || $.fn.bootstrapValidator.i18n.iban.country, $.fn.bootstrapValidator.i18n.iban.countries[country])
+                };
+            }
+
+            value = value.substr(4) + value.substr(0, 4);
+            value = $.map(value.split(''), function(n) {
+                var code = n.charCodeAt(0);
+                return (code >= 'A'.charCodeAt(0) && code <= 'Z'.charCodeAt(0))
+                        // Replace A, B, C, ..., Z with 10, 11, ..., 35
+                        ? (code - 'A'.charCodeAt(0) + 10)
+                        : n;
+            });
+            value = value.join('');
+
+            var temp   = parseInt(value.substr(0, 1), 10),
+                length = value.length;
+            for (var i = 1; i < length; ++i) {
+                temp = (temp * 10 + parseInt(value.substr(i, 1), 10)) % 97;
+            }
+
+            return {
+                valid: (temp === 1),
+                message: $.fn.bootstrapValidator.helpers.format(options.message || $.fn.bootstrapValidator.i18n.iban.country, $.fn.bootstrapValidator.i18n.iban.countries[country])
+            };
+        }
+    };
+}(window.jQuery));
+;(function($) {
+    $.fn.bootstrapValidator.i18n.id = $.extend($.fn.bootstrapValidator.i18n.id || {}, {
+        'default': 'Please enter a valid identification number',
+        countryNotSupported: 'The country code %s is not supported',
+        country: 'Please enter a valid %s identification number',
+        countries: {
+            BA: 'Bosnia and Herzegovina',
+            BG: 'Bulgarian',
+            BR: 'Brazilian',
+            CH: 'Swiss',
+            CL: 'Chilean',
+            CZ: 'Czech',
+            DK: 'Danish',
+            EE: 'Estonian',
+            ES: 'Spanish',
+            FI: 'Finnish',
+            HR: 'Croatian',
+            IE: 'Irish',
+            IS: 'Iceland',
+            LT: 'Lithuanian',
+            LV: 'Latvian',
+            ME: 'Montenegro',
+            MK: 'Macedonian',
+            NL: 'Dutch',
+            RO: 'Romanian',
+            RS: 'Serbian',
+            SE: 'Swedish',
+            SI: 'Slovenian',
+            SK: 'Slovak',
+            SM: 'San Marino',
+            ZA: 'South African'
+        }
+    });
+
+    $.fn.bootstrapValidator.validators.id = {
+        html5Attributes: {
+            message: 'message',
+            country: 'country'
+        },
+
+        // Supported country codes
+        COUNTRY_CODES: [
+            'BA', 'BG', 'BR', 'CH', 'CL', 'CZ', 'DK', 'EE', 'ES', 'FI', 'HR', 'IE', 'IS', 'LT', 'LV', 'ME', 'MK', 'NL',
+            'RO', 'RS', 'SE', 'SI', 'SK', 'SM', 'ZA'
+        ],
+
+        /**
+         * Validate identification number in different countries
+         *
+         * @see http://en.wikipedia.org/wiki/National_identification_number
+         * @param {BootstrapValidator} validator The validator plugin instance
+         * @param {jQuery} $field Field element
+         * @param {Object} options Consist of key:
+         * - message: The invalid message
+         * - country: The ISO 3166-1 country code. It can be
+         *      - One of country code defined in COUNTRY_CODES
+         *      - Name of field which its value defines the country code
+         *      - Name of callback function that returns the country code
+         *      - A callback function that returns the country code
+         * @returns {Boolean|Object}
+         */
+        validate: function(validator, $field, options) {
+            var value = $field.val();
+            if (value === '') {
+                return true;
+            }
+
+            var country = options.country;
+            if (!country) {
+                country = value.substr(0, 2);
+            } else if (typeof country !== 'string' || $.inArray(country.toUpperCase(), this.COUNTRY_CODES) === -1) {
+                // Determine the country code
+                country = validator.getDynamicOption($field, country);
+            }
+
+            if ($.inArray(country, this.COUNTRY_CODES) === -1) {
+                return { valid: false, message: $.fn.bootstrapValidator.helpers.format($.fn.bootstrapValidator.i18n.id.countryNotSupported, country) };
+            }
+
+            var method  = ['_', country.toLowerCase()].join('');
+            return this[method](value)
+                    ? true
+                    : {
+                        valid: false,
+                        message: $.fn.bootstrapValidator.helpers.format(options.message || $.fn.bootstrapValidator.i18n.id.country, $.fn.bootstrapValidator.i18n.id.countries[country.toUpperCase()])
+                    };
+        },
+
+        /**
+         * Validate Unique Master Citizen Number which uses in
+         * - Bosnia and Herzegovina (country code: BA)
+         * - Macedonia (MK)
+         * - Montenegro (ME)
+         * - Serbia (RS)
+         * - Slovenia (SI)
+         *
+         * @see http://en.wikipedia.org/wiki/Unique_Master_Citizen_Number
+         * @param {String} value The ID
+         * @param {String} countryCode The ISO country code, can be BA, MK, ME, RS, SI
+         * @returns {Boolean}
+         */
+        _validateJMBG: function(value, countryCode) {
+            if (!/^\d{13}$/.test(value)) {
+                return false;
+            }
+            var day   = parseInt(value.substr(0, 2), 10),
+                month = parseInt(value.substr(2, 2), 10),
+                year  = parseInt(value.substr(4, 3), 10),
+                rr    = parseInt(value.substr(7, 2), 10),
+                k     = parseInt(value.substr(12, 1), 10);
+
+            // Validate date of birth
+            // FIXME: Validate the year of birth
+            if (day > 31 || month > 12) {
+                return false;
+            }
+
+            // Validate checksum
+            var sum = 0;
+            for (var i = 0; i < 6; i++) {
+                sum += (7 - i) * (parseInt(value.charAt(i), 10) + parseInt(value.charAt(i + 6), 10));
+            }
+            sum = 11 - sum % 11;
+            if (sum === 10 || sum === 11) {
+                sum = 0;
+            }
+            if (sum !== k) {
+                return false;
+            }
+
+            // Validate political region
+            // rr is the political region of birth, which can be in ranges:
+            // 10-19: Bosnia and Herzegovina
+            // 20-29: Montenegro
+            // 30-39: Croatia (not used anymore)
+            // 41-49: Macedonia
+            // 50-59: Slovenia (only 50 is used)
+            // 70-79: Central Serbia
+            // 80-89: Serbian province of Vojvodina
+            // 90-99: Kosovo
+            switch (countryCode.toUpperCase()) {
+                case 'BA':
+                    return (10 <= rr && rr <= 19);
+                case 'MK':
+                    return (41 <= rr && rr <= 49);
+                case 'ME':
+                    return (20 <= rr && rr <= 29);
+                case 'RS':
+                    return (70 <= rr && rr <= 99);
+                case 'SI':
+                    return (50 <= rr && rr <= 59);
+                default:
+                    return true;
+            }
+        },
+
+        _ba: function(value) {
+            return this._validateJMBG(value, 'BA');
+        },
+        _mk: function(value) {
+            return this._validateJMBG(value, 'MK');
+        },
+        _me: function(value) {
+            return this._validateJMBG(value, 'ME');
+        },
+        _rs: function(value) {
+            return this._validateJMBG(value, 'RS');
+        },
+
+        /**
+         * Examples: 0101006500006
+         */
+        _si: function(value) {
+            return this._validateJMBG(value, 'SI');
+        },
+
+        /**
+         * Validate Bulgarian national identification number (EGN)
+         * Examples:
+         * - Valid: 7523169263, 8032056031, 803205 603 1, 8001010008, 7501020018, 7552010005, 7542011030
+         * - Invalid: 8019010008
+         *
+         * @see http://en.wikipedia.org/wiki/Uniform_civil_number
+         * @param {String} value The ID
+         * @returns {Boolean}
+         */
+        _bg: function(value) {
+            if (!/^\d{10}$/.test(value) && !/^\d{6}\s\d{3}\s\d{1}$/.test(value)) {
+                return false;
+            }
+            value = value.replace(/\s/g, '');
+            // Check the birth date
+            var year  = parseInt(value.substr(0, 2), 10) + 1900,
+                month = parseInt(value.substr(2, 2), 10),
+                day   = parseInt(value.substr(4, 2), 10);
+            if (month > 40) {
+                year += 100;
+                month -= 40;
+            } else if (month > 20) {
+                year -= 100;
+                month -= 20;
+            }
+
+            if (!$.fn.bootstrapValidator.helpers.date(year, month, day)) {
+                return false;
+            }
+
+            var sum    = 0,
+                weight = [2, 4, 8, 5, 10, 9, 7, 3, 6];
+            for (var i = 0; i < 9; i++) {
+                sum += parseInt(value.charAt(i), 10) * weight[i];
+            }
+            sum = (sum % 11) % 10;
+            return (sum + '' === value.substr(9, 1));
+        },
+
+        /**
+         * Validate Brazilian national identification number (CPF)
+         * Examples:
+         * - Valid: 39053344705, 390.533.447-05, 111.444.777-35
+         * - Invalid: 231.002.999-00
+         *
+         * @see http://en.wikipedia.org/wiki/Cadastro_de_Pessoas_F%C3%ADsicas
+         * @param {String} value The ID
+         * @returns {Boolean}
+         */
+        _br: function(value) {
+            if (/^1{11}|2{11}|3{11}|4{11}|5{11}|6{11}|7{11}|8{11}|9{11}|0{11}$/.test(value)) {
+                return false;
+            }
+            if (!/^\d{11}$/.test(value) && !/^\d{3}\.\d{3}\.\d{3}-\d{2}$/.test(value)) {
+                return false;
+            }
+            value = value.replace(/\./g, '').replace(/-/g, '');
+
+            var d1 = 0;
+            for (var i = 0; i < 9; i++) {
+                d1 += (10 - i) * parseInt(value.charAt(i), 10);
+            }
+            d1 = 11 - d1 % 11;
+            if (d1 === 10 || d1 === 11) {
+                d1 = 0;
+            }
+            if (d1 + '' !== value.charAt(9)) {
+                return false;
+            }
+
+            var d2 = 0;
+            for (i = 0; i < 10; i++) {
+                d2 += (11 - i) * parseInt(value.charAt(i), 10);
+            }
+            d2 = 11 - d2 % 11;
+            if (d2 === 10 || d2 === 11) {
+                d2 = 0;
+            }
+
+            return (d2 + '' === value.charAt(10));
+        },
+
+        /**
+         * Validate Swiss Social Security Number (AHV-Nr/No AVS)
+         * Examples:
+         * - Valid: 756.1234.5678.95, 7561234567895
+         *
+         * @see http://en.wikipedia.org/wiki/National_identification_number#Switzerland
+         * @see http://www.bsv.admin.ch/themen/ahv/00011/02185/index.html?lang=de
+         * @param {String} value The ID
+         * @returns {Boolean}
+         */
+        _ch: function(value) {
+            if (!/^756[\.]{0,1}[0-9]{4}[\.]{0,1}[0-9]{4}[\.]{0,1}[0-9]{2}$/.test(value)) {
+                return false;
+            }
+            value = value.replace(/\D/g, '').substr(3);
+            var length = value.length,
+                sum    = 0,
+                weight = (length === 8) ? [3, 1] : [1, 3];
+            for (var i = 0; i < length - 1; i++) {
+                sum += parseInt(value.charAt(i), 10) * weight[i % 2];
+            }
+            sum = 10 - sum % 10;
+            return (sum + '' === value.charAt(length - 1));
+        },
+
+        /**
+         * Validate Chilean national identification number (RUN/RUT)
+         * Examples:
+         * - Valid: 76086428-5, 22060449-7, 12531909-2
+         *
+         * @see http://en.wikipedia.org/wiki/National_identification_number#Chile
+         * @see https://palena.sii.cl/cvc/dte/ee_empresas_emisoras.html for samples
+         * @param {String} value The ID
+         * @returns {Boolean}
+         */
+        _cl: function(value) {
+            if (!/^\d{7,8}[-]{0,1}[0-9K]$/i.test(value)) {
+                return false;
+            }
+            value = value.replace(/\-/g, '');
+            while (value.length < 9) {
+                value = '0' + value;
+            }
+            var sum    = 0,
+                weight = [3, 2, 7, 6, 5, 4, 3, 2];
+            for (var i = 0; i < 8; i++) {
+                sum += parseInt(value.charAt(i), 10) * weight[i];
+            }
+            sum = 11 - sum % 11;
+            if (sum === 11) {
+                sum = 0;
+            } else if (sum === 10) {
+                sum = 'K';
+            }
+            return sum + '' === value.charAt(8).toUpperCase();
+        },
+
+        /**
+         * Validate Czech national identification number (RC)
+         * Examples:
+         * - Valid: 7103192745, 991231123
+         * - Invalid: 1103492745, 590312123
+         *
+         * @param {String} value The ID
+         * @returns {Boolean}
+         */
+        _cz: function(value) {
+            if (!/^\d{9,10}$/.test(value)) {
+                return false;
+            }
+            var year  = 1900 + parseInt(value.substr(0, 2), 10),
+                month = parseInt(value.substr(2, 2), 10) % 50 % 20,
+                day   = parseInt(value.substr(4, 2), 10);
+            if (value.length === 9) {
+                if (year >= 1980) {
+                    year -= 100;
+                }
+                if (year > 1953) {
+                    return false;
+                }
+            } else if (year < 1954) {
+                year += 100;
+            }
+
+            if (!$.fn.bootstrapValidator.helpers.date(year, month, day)) {
+                return false;
+            }
+
+            // Check that the birth date is not in the future
+            if (value.length === 10) {
+                var check = parseInt(value.substr(0, 9), 10) % 11;
+                if (year < 1985) {
+                    check = check % 10;
+                }
+                return (check + '' === value.substr(9, 1));
+            }
+
+            return true;
+        },
+
+        /**
+         * Validate Danish Personal Identification number (CPR)
+         * Examples:
+         * - Valid: 2110625629, 211062-5629
+         * - Invalid: 511062-5629
+         *
+         * @see https://en.wikipedia.org/wiki/Personal_identification_number_(Denmark)
+         * @param {String} value The ID
+         * @returns {Boolean}
+         */
+        _dk: function(value) {
+            if (!/^[0-9]{6}[-]{0,1}[0-9]{4}$/.test(value)) {
+                return false;
+            }
+            value = value.replace(/-/g, '');
+            var day   = parseInt(value.substr(0, 2), 10),
+                month = parseInt(value.substr(2, 2), 10),
+                year  = parseInt(value.substr(4, 2), 10);
+
+            switch (true) {
+                case ('5678'.indexOf(value.charAt(6)) !== -1 && year >= 58):
+                    year += 1800;
+                    break;
+                case ('0123'.indexOf(value.charAt(6)) !== -1):
+                case ('49'.indexOf(value.charAt(6)) !== -1 && year >= 37):
+                    year += 1900;
+                    break;
+                default:
+                    year += 2000;
+                    break;
+            }
+
+            return $.fn.bootstrapValidator.helpers.date(year, month, day);
+        },
+
+        /**
+         * Validate Estonian Personal Identification Code (isikukood)
+         * Examples:
+         * - Valid: 37605030299
+         *
+         * @see http://et.wikipedia.org/wiki/Isikukood
+         * @param {String} value The ID
+         * @returns {Boolean}
+         */
+        _ee: function(value) {
+            // Use the same format as Lithuanian Personal Code
+            return this._lt(value);
+        },
+
+        /**
+         * Validate Spanish personal identity code (DNI)
+         * Support i) DNI (for Spanish citizens) and ii) NIE (for foreign people)
+         *
+         * Examples:
+         * - Valid: i) 54362315K, 54362315-K; ii) X2482300W, X-2482300W, X-2482300-W
+         * - Invalid: i) 54362315Z; ii) X-2482300A
+         *
+         * @see https://en.wikipedia.org/wiki/National_identification_number#Spain
+         * @param {String} value The ID
+         * @returns {Boolean}
+         */
+        _es: function(value) {
+            if (!/^[0-9A-Z]{8}[-]{0,1}[0-9A-Z]$/.test(value)                    // DNI
+                && !/^[XYZ][-]{0,1}[0-9]{7}[-]{0,1}[0-9A-Z]$/.test(value)) {    // NIE
+                return false;
+            }
+
+            value = value.replace(/-/g, '');
+            var index = 'XYZ'.indexOf(value.charAt(0));
+            if (index !== -1) {
+                // It is NIE number
+                value = index + value.substr(1) + '';
+            }
+
+            var check = parseInt(value.substr(0, 8), 10);
+            check = 'TRWAGMYFPDXBNJZSQVHLCKE'[check % 23];
+            return (check === value.substr(8, 1));
+        },
+
+        /**
+         * Validate Finnish Personal Identity Code (HETU)
+         * Examples:
+         * - Valid: 311280-888Y, 131052-308T
+         * - Invalid: 131052-308U, 310252-308Y
+         *
+         * @param {String} value The ID
+         * @returns {Boolean}
+         */
+        _fi: function(value) {
+            if (!/^[0-9]{6}[-+A][0-9]{3}[0-9ABCDEFHJKLMNPRSTUVWXY]$/.test(value)) {
+                return false;
+            }
+            var day       = parseInt(value.substr(0, 2), 10),
+                month     = parseInt(value.substr(2, 2), 10),
+                year      = parseInt(value.substr(4, 2), 10),
+                centuries = {
+                    '+': 1800,
+                    '-': 1900,
+                    'A': 2000
+                };
+            year = centuries[value.charAt(6)] + year;
+
+            if (!$.fn.bootstrapValidator.helpers.date(year, month, day)) {
+                return false;
+            }
+
+            var individual = parseInt(value.substr(7, 3), 10);
+            if (individual < 2) {
+                return false;
+            }
+            var n = value.substr(0, 6) + value.substr(7, 3) + '';
+            n = parseInt(n, 10);
+            return '0123456789ABCDEFHJKLMNPRSTUVWXY'.charAt(n % 31) === value.charAt(10);
+        },
+
+        /**
+         * Validate Croatian personal identification number (OIB)
+         * Examples:
+         * - Valid: 33392005961
+         * - Invalid: 33392005962
+         *
+         * @param {String} value The ID
+         * @returns {Boolean}
+         */
+        _hr: function(value) {
+            if (!/^[0-9]{11}$/.test(value)) {
+                return false;
+            }
+            return $.fn.bootstrapValidator.helpers.mod11And10(value);
+        },
+
+        /**
+         * Validate Irish Personal Public Service Number (PPS)
+         * Examples:
+         * - Valid: 6433435F, 6433435FT, 6433435FW, 6433435OA, 6433435IH, 1234567TW, 1234567FA
+         * - Invalid: 6433435E, 6433435VH
+         *
+         * @see https://en.wikipedia.org/wiki/Personal_Public_Service_Number
+         * @param {String} value The ID
+         * @returns {Boolean}
+         */
+        _ie: function(value) {
+            if (!/^\d{7}[A-W][AHWTX]?$/.test(value)) {
+                return false;
+            }
+
+            var getCheckDigit = function(value) {
+                while (value.length < 7) {
+                    value = '0' + value;
+                }
+                var alphabet = 'WABCDEFGHIJKLMNOPQRSTUV',
+                    sum      = 0;
+                for (var i = 0; i < 7; i++) {
+                    sum += parseInt(value.charAt(i), 10) * (8 - i);
+                }
+                sum += 9 * alphabet.indexOf(value.substr(7));
+                return alphabet[sum % 23];
+            };
+
+            // 2013 format
+            if (value.length === 9 && ('A' === value.charAt(8) || 'H' === value.charAt(8))) {
+                return value.charAt(7) === getCheckDigit(value.substr(0, 7) + value.substr(8) + '');
+            }
+            // The old format
+            else {
+                return value.charAt(7) === getCheckDigit(value.substr(0, 7));
+            }
+        },
+
+        /**
+         * Validate Iceland national identification number (Kennitala)
+         * Examples:
+         * - Valid: 120174-3399, 1201743399, 0902862349
+         *
+         * @see http://en.wikipedia.org/wiki/Kennitala
+         * @param {String} value The ID
+         * @returns {Boolean}
+         */
+        _is: function(value) {
+            if (!/^[0-9]{6}[-]{0,1}[0-9]{4}$/.test(value)) {
+                return false;
+            }
+            value = value.replace(/-/g, '');
+            var day     = parseInt(value.substr(0, 2), 10),
+                month   = parseInt(value.substr(2, 2), 10),
+                year    = parseInt(value.substr(4, 2), 10),
+                century = parseInt(value.charAt(9), 10);
+
+            year = (century === 9) ? (1900 + year) : ((20 + century) * 100 + year);
+            if (!$.fn.bootstrapValidator.helpers.date(year, month, day, true)) {
+                return false;
+            }
+            // Validate the check digit
+            var sum    = 0,
+                weight = [3, 2, 7, 6, 5, 4, 3, 2];
+            for (var i = 0; i < 8; i++) {
+                sum += parseInt(value.charAt(i), 10) * weight[i];
+            }
+            sum = 11 - sum % 11;
+            return (sum + '' === value.charAt(8));
+        },
+
+        /**
+         * Validate Lithuanian Personal Code (Asmens kodas)
+         * Examples:
+         * - Valid: 38703181745
+         * - Invalid: 38703181746, 78703181745, 38703421745
+         *
+         * @see http://en.wikipedia.org/wiki/National_identification_number#Lithuania
+         * @see http://www.adomas.org/midi2007/pcode.html
+         * @param {String} value The ID
+         * @returns {Boolean}
+         */
+        _lt: function(value) {
+            if (!/^[0-9]{11}$/.test(value)) {
+                return false;
+            }
+            var gender  = parseInt(value.charAt(0), 10),
+                year    = parseInt(value.substr(1, 2), 10),
+                month   = parseInt(value.substr(3, 2), 10),
+                day     = parseInt(value.substr(5, 2), 10),
+                century = (gender % 2 === 0) ? (17 + gender / 2) : (17 + (gender + 1) / 2);
+            year = century * 100 + year;
+            if (!$.fn.bootstrapValidator.helpers.date(year, month, day, true)) {
+                return false;
+            }
+
+            // Validate the check digit
+            var sum    = 0,
+                weight = [1, 2, 3, 4, 5, 6, 7, 8, 9, 1];
+            for (var i = 0; i < 10; i++) {
+                sum += parseInt(value.charAt(i), 10) * weight[i];
+            }
+            sum = sum % 11;
+            if (sum !== 10) {
+                return sum + '' === value.charAt(10);
+            }
+
+            // Re-calculate the check digit
+            sum    = 0;
+            weight = [3, 4, 5, 6, 7, 8, 9, 1, 2, 3];
+            for (i = 0; i < 10; i++) {
+                sum += parseInt(value.charAt(i), 10) * weight[i];
+            }
+            sum = sum % 11;
+            if (sum === 10) {
+                sum = 0;
+            }
+            return (sum + '' === value.charAt(10));
+        },
+
+        /**
+         * Validate Latvian Personal Code (Personas kods)
+         * Examples:
+         * - Valid: 161175-19997, 16117519997
+         * - Invalid: 161375-19997
+         *
+         * @see http://laacz.lv/2006/11/25/pk-parbaudes-algoritms/
+         * @param {String} value The ID
+         * @returns {Boolean}
+         */
+        _lv: function(value) {
+            if (!/^[0-9]{6}[-]{0,1}[0-9]{5}$/.test(value)) {
+                return false;
+            }
+            value = value.replace(/\D/g, '');
+            // Check birth date
+            var day   = parseInt(value.substr(0, 2), 10),
+                month = parseInt(value.substr(2, 2), 10),
+                year  = parseInt(value.substr(4, 2), 10);
+            year = year + 1800 + parseInt(value.charAt(6), 10) * 100;
+
+            if (!$.fn.bootstrapValidator.helpers.date(year, month, day, true)) {
+                return false;
+            }
+
+            // Check personal code
+            var sum    = 0,
+                weight = [10, 5, 8, 4, 2, 1, 6, 3, 7, 9];
+            for (var i = 0; i < 10; i++) {
+                sum += parseInt(value.charAt(i), 10) * weight[i];
+            }
+            sum = (sum + 1) % 11 % 10;
+            return (sum + '' === value.charAt(10));
+        },
+
+        /**
+         * Validate Dutch national identification number (BSN)
+         * Examples:
+         * - Valid: 111222333, 941331490, 9413.31.490
+         * - Invalid: 111252333
+         *
+         * @see https://nl.wikipedia.org/wiki/Burgerservicenummer
+         * @param {String} value The ID
+         * @returns {Boolean}
+         */
+        _nl: function(value) {
+            while (value.length < 9) {
+                value = '0' + value;
+            }
+            if (!/^[0-9]{4}[.]{0,1}[0-9]{2}[.]{0,1}[0-9]{3}$/.test(value)) {
+                return false;
+            }
+            value = value.replace(/\./g, '');
+            if (parseInt(value, 10) === 0) {
+                return false;
+            }
+            var sum    = 0,
+                length = value.length;
+            for (var i = 0; i < length - 1; i++) {
+                sum += (9 - i) * parseInt(value.charAt(i), 10);
+            }
+            sum = sum % 11;
+            if (sum === 10) {
+                sum = 0;
+            }
+            return (sum + '' === value.charAt(length - 1));
+        },
+
+        /**
+         * Validate Romanian numerical personal code (CNP)
+         * Examples:
+         * - Valid: 1630615123457, 1800101221144
+         * - Invalid: 8800101221144, 1632215123457, 1630615123458
+         *
+         * @see http://en.wikipedia.org/wiki/National_identification_number#Romania
+         * @param {String} value The ID
+         * @returns {Boolean}
+         */
+        _ro: function(value) {
+            if (!/^[0-9]{13}$/.test(value)) {
+                return false;
+            }
+            var gender = parseInt(value.charAt(0), 10);
+            if (gender === 0 || gender === 7 || gender === 8) {
+                return false;
+            }
+
+            // Determine the date of birth
+            var year      = parseInt(value.substr(1, 2), 10),
+                month     = parseInt(value.substr(3, 2), 10),
+                day       = parseInt(value.substr(5, 2), 10),
+                // The year of date is determined base on the gender
+                centuries = {
+                    '1': 1900,  // Male born between 1900 and 1999
+                    '2': 1900,  // Female born between 1900 and 1999
+                    '3': 1800,  // Male born between 1800 and 1899
+                    '4': 1800,  // Female born between 1800 and 1899
+                    '5': 2000,  // Male born after 2000
+                    '6': 2000   // Female born after 2000
+                };
+            if (day > 31 && month > 12) {
+                return false;
+            }
+            if (gender !== 9) {
+                year = centuries[gender + ''] + year;
+                if (!$.fn.bootstrapValidator.helpers.date(year, month, day)) {
+                    return false;
+                }
+            }
+
+            // Validate the check digit
+            var sum    = 0,
+                weight = [2, 7, 9, 1, 4, 6, 3, 5, 8, 2, 7, 9],
+                length = value.length;
+            for (var i = 0; i < length - 1; i++) {
+                sum += parseInt(value.charAt(i), 10) * weight[i];
+            }
+            sum = sum % 11;
+            if (sum === 10) {
+                sum = 1;
+            }
+            return (sum + '' === value.charAt(length - 1));
+        },
+
+        /**
+         * Validate Swedish personal identity number (personnummer)
+         * Examples:
+         * - Valid: 8112289874, 811228-9874, 811228+9874
+         * - Invalid: 811228-9873
+         *
+         * @see http://en.wikipedia.org/wiki/Personal_identity_number_(Sweden)
+         * @param {String} value The ID
+         * @returns {Boolean}
+         */
+        _se: function(value) {
+            if (!/^[0-9]{10}$/.test(value) && !/^[0-9]{6}[-|+][0-9]{4}$/.test(value)) {
+                return false;
+            }
+            value = value.replace(/[^0-9]/g, '');
+
+            var year  = parseInt(value.substr(0, 2), 10) + 1900,
+                month = parseInt(value.substr(2, 2), 10),
+                day   = parseInt(value.substr(4, 2), 10);
+            if (!$.fn.bootstrapValidator.helpers.date(year, month, day)) {
+                return false;
+            }
+
+            // Validate the last check digit
+            return $.fn.bootstrapValidator.helpers.luhn(value);
+        },
+
+        /**
+         * Validate Slovak national identifier number (RC)
+         * Examples:
+         * - Valid: 7103192745, 991231123
+         * - Invalid: 7103192746, 1103492745
+         *
+         * @param {String} value The ID
+         * @returns {Boolean}
+         */
+        _sk: function(value) {
+            // Slovakia uses the same format as Czech Republic
+            return this._cz(value);
+        },
+
+        /**
+         * Validate San Marino citizen number
+         *
+         * @see http://en.wikipedia.org/wiki/National_identification_number#San_Marino
+         * @param {String} value The ID
+         * @returns {Boolean}
+         */
+        _sm: function(value) {
+            return /^\d{5}$/.test(value);
+        },
+
+        /**
+         * Validate South African ID
+         * Example:
+         * - Valid: 8001015009087
+         * - Invalid: 8001015009287, 8001015009086
+         *
+         * @see http://en.wikipedia.org/wiki/National_identification_number#South_Africa
+         * @param {String} value The ID
+         * @returns {Boolean}
+         */
+        _za: function(value) {
+            if (!/^[0-9]{10}[0|1][8|9][0-9]$/.test(value)) {
+                return false;
+            }
+            var year        = parseInt(value.substr(0, 2), 10),
+                currentYear = new Date().getFullYear() % 100,
+                month       = parseInt(value.substr(2, 2), 10),
+                day         = parseInt(value.substr(4, 2), 10);
+            year = (year >= currentYear) ? (year + 1900) : (year + 2000);
+
+            if (!$.fn.bootstrapValidator.helpers.date(year, month, day)) {
+                return false;
+            }
+
+            // Validate the last check digit
+            return $.fn.bootstrapValidator.helpers.luhn(value);
+        }
+    };
+}(window.jQuery));
+;(function($) {
+    $.fn.bootstrapValidator.i18n.identical = $.extend($.fn.bootstrapValidator.i18n.identical || {}, {
+        'default': 'Please enter the same value'
+    });
+
+    $.fn.bootstrapValidator.validators.identical = {
+        html5Attributes: {
+            message: 'message',
+            field: 'field'
+        },
+
+        /**
+         * Check if input value equals to value of particular one
+         *
+         * @param {BootstrapValidator} validator The validator plugin instance
+         * @param {jQuery} $field Field element
+         * @param {Object} options Consists of the following key:
+         * - field: The name of field that will be used to compare with current one
+         * @returns {Boolean}
+         */
+        validate: function(validator, $field, options) {
+            var value = $field.val();
+            if (value === '') {
+                return true;
+            }
+
+            var compareWith = validator.getFieldElements(options.field);
+            if (compareWith === null) {
+                return true;
+            }
+
+            if (value === compareWith.val()) {
+                validator.updateStatus(options.field, validator.STATUS_VALID, 'identical');
+                return true;
+            } else {
+                return false;
+            }
+        }
+    };
+}(window.jQuery));
+;(function($) {
+    $.fn.bootstrapValidator.i18n.imei = $.extend($.fn.bootstrapValidator.i18n.imei || {}, {
+        'default': 'Please enter a valid IMEI number'
+    });
+
+    $.fn.bootstrapValidator.validators.imei = {
+        /**
+         * Validate IMEI (International Mobile Station Equipment Identity)
+         * Examples:
+         * - Valid: 35-209900-176148-1, 35-209900-176148-23, 3568680000414120, 490154203237518
+         * - Invalid: 490154203237517
+         *
+         * @see http://en.wikipedia.org/wiki/International_Mobile_Station_Equipment_Identity
+         * @param {BootstrapValidator} validator The validator plugin instance
+         * @param {jQuery} $field Field element
+         * @param {Object} options Can consist of the following keys:
+         * - message: The invalid message
+         * @returns {Boolean}
+         */
+        validate: function(validator, $field, options) {
+            var value = $field.val();
+            if (value === '') {
+                return true;
+            }
+
+            switch (true) {
+                case /^\d{15}$/.test(value):
+                case /^\d{2}-\d{6}-\d{6}-\d{1}$/.test(value):
+                case /^\d{2}\s\d{6}\s\d{6}\s\d{1}$/.test(value):
+                    value = value.replace(/[^0-9]/g, '');
+                    return $.fn.bootstrapValidator.helpers.luhn(value);
+
+                case /^\d{14}$/.test(value):
+                case /^\d{16}$/.test(value):
+                case /^\d{2}-\d{6}-\d{6}(|-\d{2})$/.test(value):
+                case /^\d{2}\s\d{6}\s\d{6}(|\s\d{2})$/.test(value):
+                    return true;
+
+                default:
+                    return false;
+            }
+        }
+    };
+}(window.jQuery));
+;(function($) {
+    $.fn.bootstrapValidator.i18n.integer = $.extend($.fn.bootstrapValidator.i18n.integer || {}, {
+        'default': 'Please enter a valid number'
+    });
+
+    $.fn.bootstrapValidator.validators.integer = {
+        enableByHtml5: function($field) {
+            return ('number' === $field.attr('type')) && ($field.attr('step') === undefined || $field.attr('step') % 1 === 0);
+        },
+
+        /**
+         * Return true if the input value is an integer
+         *
+         * @param {BootstrapValidator} validator The validator plugin instance
+         * @param {jQuery} $field Field element
+         * @param {Object} options Can consist of the following key:
+         * - message: The invalid message
+         * @returns {Boolean}
+         */
+        validate: function(validator, $field, options) {
+            var value = $field.val();
+            if (value === '') {
+                return true;
+            }
+            return /^(?:-?(?:0|[1-9][0-9]*))$/.test(value);
+        }
+    };
+}(window.jQuery));
+;(function($) {
+    $.fn.bootstrapValidator.i18n.ip = $.extend($.fn.bootstrapValidator.i18n.ip || {}, {
+        'default': 'Please enter a valid IP address',
+        ipv4: 'Please enter a valid IPv4 address',
+        ipv6: 'Please enter a valid IPv6 address'
+    });
+
+    $.fn.bootstrapValidator.validators.ip = {
+        html5Attributes: {
+            message: 'message',
+            ipv4: 'ipv4',
+            ipv6: 'ipv6'
+        },
+
+        /**
+         * Return true if the input value is a IP address.
+         *
+         * @param {BootstrapValidator} validator The validator plugin instance
+         * @param {jQuery} $field Field element
+         * @param {Object} options Can consist of the following keys:
+         * - ipv4: Enable IPv4 validator, default to true
+         * - ipv6: Enable IPv6 validator, default to true
+         * - message: The invalid message
+         * @returns {Boolean|Object}
+         */
+        validate: function(validator, $field, options) {
+            var value = $field.val();
+            if (value === '') {
+                return true;
+            }
+            options = $.extend({}, { ipv4: true, ipv6: true }, options);
+
+            if (options.ipv4) {
+                return {
+                    valid: /^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/.test(value),
+                    message: options.message || $.fn.bootstrapValidator.i18n.ip.ipv4
+                };
+            } else if (options.ipv6) {
+                return {
+                    valid: /^\s*((([0-9A-Fa-f]{1,4}:){7}([0-9A-Fa-f]{1,4}|:))|(([0-9A-Fa-f]{1,4}:){6}(:[0-9A-Fa-f]{1,4}|((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(([0-9A-Fa-f]{1,4}:){5}(((:[0-9A-Fa-f]{1,4}){1,2})|:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(([0-9A-Fa-f]{1,4}:){4}(((:[0-9A-Fa-f]{1,4}){1,3})|((:[0-9A-Fa-f]{1,4})?:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9A-Fa-f]{1,4}:){3}(((:[0-9A-Fa-f]{1,4}){1,4})|((:[0-9A-Fa-f]{1,4}){0,2}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9A-Fa-f]{1,4}:){2}(((:[0-9A-Fa-f]{1,4}){1,5})|((:[0-9A-Fa-f]{1,4}){0,3}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9A-Fa-f]{1,4}:){1}(((:[0-9A-Fa-f]{1,4}){1,6})|((:[0-9A-Fa-f]{1,4}){0,4}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(:(((:[0-9A-Fa-f]{1,4}){1,7})|((:[0-9A-Fa-f]{1,4}){0,5}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:)))(%.+)?\s*$/.test(value),
+                    message: options.message || $.fn.bootstrapValidator.i18n.ip.ipv6
+                };
+            }
+
+            return false;
+        }
+    };
+}(window.jQuery));
+;(function($) {
+    $.fn.bootstrapValidator.i18n.isbn = $.extend($.fn.bootstrapValidator.i18n.isbn || {}, {
+        'default': 'Please enter a valid ISBN number'
+    });
+
+    $.fn.bootstrapValidator.validators.isbn = {
+        /**
+         * Return true if the input value is a valid ISBN 10 or ISBN 13 number
+         * Examples:
+         * - Valid:
+         * ISBN 10: 99921-58-10-7, 9971-5-0210-0, 960-425-059-0, 80-902734-1-6, 85-359-0277-5, 1-84356-028-3, 0-684-84328-5, 0-8044-2957-X, 0-85131-041-9, 0-943396-04-2, 0-9752298-0-X
+         * ISBN 13: 978-0-306-40615-7
+         * - Invalid:
+         * ISBN 10: 99921-58-10-6
+         * ISBN 13: 978-0-306-40615-6
+         *
+         * @see http://en.wikipedia.org/wiki/International_Standard_Book_Number
+         * @param {BootstrapValidator} validator The validator plugin instance
+         * @param {jQuery} $field Field element
+         * @param {Object} [options] Can consist of the following keys:
+         * - message: The invalid message
+         * @returns {Boolean}
+         */
+        validate: function(validator, $field, options) {
+            var value = $field.val();
+            if (value === '') {
+                return true;
+            }
+
+            // http://en.wikipedia.org/wiki/International_Standard_Book_Number#Overview
+            // Groups are separated by a hyphen or a space
+            var type;
+            switch (true) {
+                case /^\d{9}[\dX]$/.test(value):
+                case (value.length === 13 && /^(\d+)-(\d+)-(\d+)-([\dX])$/.test(value)):
+                case (value.length === 13 && /^(\d+)\s(\d+)\s(\d+)\s([\dX])$/.test(value)):
+                    type = 'ISBN10';
+                    break;
+                case /^(978|979)\d{9}[\dX]$/.test(value):
+                case (value.length === 17 && /^(978|979)-(\d+)-(\d+)-(\d+)-([\dX])$/.test(value)):
+                case (value.length === 17 && /^(978|979)\s(\d+)\s(\d+)\s(\d+)\s([\dX])$/.test(value)):
+                    type = 'ISBN13';
+                    break;
+                default:
+                    return false;
+            }
+
+            // Replace all special characters except digits and X
+            value = value.replace(/[^0-9X]/gi, '');
+            var chars  = value.split(''),
+                length = chars.length,
+                sum    = 0,
+                i,
+                checksum;
+
+            switch (type) {
+                case 'ISBN10':
+                    sum = 0;
+                    for (i = 0; i < length - 1; i++) {
+                        sum += parseInt(chars[i], 10) * (10 - i);
+                    }
+                    checksum = 11 - (sum % 11);
+                    if (checksum === 11) {
+                        checksum = 0;
+                    } else if (checksum === 10) {
+                        checksum = 'X';
+                    }
+                    return (checksum + '' === chars[length - 1]);
+
+                case 'ISBN13':
+                    sum = 0;
+                    for (i = 0; i < length - 1; i++) {
+                        sum += ((i % 2 === 0) ? parseInt(chars[i], 10) : (parseInt(chars[i], 10) * 3));
+                    }
+                    checksum = 10 - (sum % 10);
+                    if (checksum === 10) {
+                        checksum = '0';
+                    }
+                    return (checksum + '' === chars[length - 1]);
+
+                default:
+                    return false;
+            }
+        }
+    };
+}(window.jQuery));
+;(function($) {
+    $.fn.bootstrapValidator.i18n.isin = $.extend($.fn.bootstrapValidator.i18n.isin || {}, {
+        'default': 'Please enter a valid ISIN number'
+    });
+
+    $.fn.bootstrapValidator.validators.isin = {
+        // Available country codes
+        // See http://isin.net/country-codes/
+        COUNTRY_CODES: 'AF|AX|AL|DZ|AS|AD|AO|AI|AQ|AG|AR|AM|AW|AU|AT|AZ|BS|BH|BD|BB|BY|BE|BZ|BJ|BM|BT|BO|BQ|BA|BW|BV|BR|IO|BN|BG|BF|BI|KH|CM|CA|CV|KY|CF|TD|CL|CN|CX|CC|CO|KM|CG|CD|CK|CR|CI|HR|CU|CW|CY|CZ|DK|DJ|DM|DO|EC|EG|SV|GQ|ER|EE|ET|FK|FO|FJ|FI|FR|GF|PF|TF|GA|GM|GE|DE|GH|GI|GR|GL|GD|GP|GU|GT|GG|GN|GW|GY|HT|HM|VA|HN|HK|HU|IS|IN|ID|IR|IQ|IE|IM|IL|IT|JM|JP|JE|JO|KZ|KE|KI|KP|KR|KW|KG|LA|LV|LB|LS|LR|LY|LI|LT|LU|MO|MK|MG|MW|MY|MV|ML|MT|MH|MQ|MR|MU|YT|MX|FM|MD|MC|MN|ME|MS|MA|MZ|MM|NA|NR|NP|NL|NC|NZ|NI|NE|NG|NU|NF|MP|NO|OM|PK|PW|PS|PA|PG|PY|PE|PH|PN|PL|PT|PR|QA|RE|RO|RU|RW|BL|SH|KN|LC|MF|PM|VC|WS|SM|ST|SA|SN|RS|SC|SL|SG|SX|SK|SI|SB|SO|ZA|GS|SS|ES|LK|SD|SR|SJ|SZ|SE|CH|SY|TW|TJ|TZ|TH|TL|TG|TK|TO|TT|TN|TR|TM|TC|TV|UG|UA|AE|GB|US|UM|UY|UZ|VU|VE|VN|VG|VI|WF|EH|YE|ZM|ZW',
+
+        /**
+         * Validate an ISIN (International Securities Identification Number)
+         * Examples:
+         * - Valid: US0378331005, AU0000XVGZA3, GB0002634946
+         * - Invalid: US0378331004, AA0000XVGZA3
+         *
+         * @see http://en.wikipedia.org/wiki/International_Securities_Identifying_Number
+         * @param {BootstrapValidator} validator The validator plugin instance
+         * @param {jQuery} $field Field element
+         * @param {Object} options Can consist of the following keys:
+         * - message: The invalid message
+         * @returns {Boolean}
+         */
+        validate: function(validator, $field, options) {
+            var value = $field.val();
+            if (value === '') {
+                return true;
+            }
+
+            value = value.toUpperCase();
+            var regex = new RegExp('^(' + this.COUNTRY_CODES + ')[0-9A-Z]{10}$');
+            if (!regex.test(value)) {
+                return false;
+            }
+
+            var converted = '',
+                length    = value.length;
+            // Convert letters to number
+            for (var i = 0; i < length - 1; i++) {
+                var c = value.charCodeAt(i);
+                converted += ((c > 57) ? (c - 55).toString() : value.charAt(i));
+            }
+
+            var digits = '',
+                n      = converted.length,
+                group  = (n % 2 !== 0) ? 0 : 1;
+            for (i = 0; i < n; i++) {
+                digits += (parseInt(converted[i], 10) * ((i % 2) === group ? 2 : 1) + '');
+            }
+
+            var sum = 0;
+            for (i = 0; i < digits.length; i++) {
+                sum += parseInt(digits.charAt(i), 10);
+            }
+            sum = (10 - (sum % 10)) % 10;
+            return sum + '' === value.charAt(length - 1);
+        }
+    };
+}(window.jQuery));
+;(function($) {
+    $.fn.bootstrapValidator.i18n.ismn = $.extend($.fn.bootstrapValidator.i18n.ismn || {}, {
+        'default': 'Please enter a valid ISMN number'
+    });
+
+    $.fn.bootstrapValidator.validators.ismn = {
+        /**
+         * Validate ISMN (International Standard Music Number)
+         * Examples:
+         * - Valid: M230671187, 979-0-0601-1561-5, 979 0 3452 4680 5, 9790060115615
+         * - Invalid: 9790060115614
+         *
+         * @see http://en.wikipedia.org/wiki/International_Standard_Music_Number
+         * @param {BootstrapValidator} validator The validator plugin instance
+         * @param {jQuery} $field Field element
+         * @param {Object} options Can consist of the following keys:
+         * - message: The invalid message
+         * @returns {Boolean}
+         */
+        validate: function(validator, $field, options) {
+            var value = $field.val();
+            if (value === '') {
+                return true;
+            }
+
+            // Groups are separated by a hyphen or a space
+            var type;
+            switch (true) {
+                case /^M\d{9}$/.test(value):
+                case /^M-\d{4}-\d{4}-\d{1}$/.test(value):
+                case /^M\s\d{4}\s\d{4}\s\d{1}$/.test(value):
+                    type = 'ISMN10';
+                    break;
+                case /^9790\d{9}$/.test(value):
+                case /^979-0-\d{4}-\d{4}-\d{1}$/.test(value):
+                case /^979\s0\s\d{4}\s\d{4}\s\d{1}$/.test(value):
+                    type = 'ISMN13';
+                    break;
+                default:
+                    return false;
+            }
+
+            if ('ISMN10' === type) {
+                value = '9790' + value.substr(1);
+            }
+
+            // Replace all special characters except digits
+            value = value.replace(/[^0-9]/gi, '');
+            var length = value.length,
+                sum    = 0,
+                weight = [1, 3];
+            for (var i = 0; i < length - 1; i++) {
+                sum += parseInt(value.charAt(i), 10) * weight[i % 2];
+            }
+            sum = 10 - sum % 10;
+            return (sum + '' === value.charAt(length - 1));
+        }
+    };
+}(window.jQuery));
+;(function($) {
+    $.fn.bootstrapValidator.i18n.issn = $.extend($.fn.bootstrapValidator.i18n.issn || {}, {
+        'default': 'Please enter a valid ISSN number'
+    });
+
+    $.fn.bootstrapValidator.validators.issn = {
+        /**
+         * Validate ISSN (International Standard Serial Number)
+         * Examples:
+         * - Valid: 0378-5955, 0024-9319, 0032-1478
+         * - Invalid: 0032-147X
+         *
+         * @see http://en.wikipedia.org/wiki/International_Standard_Serial_Number
+         * @param {BootstrapValidator} validator The validator plugin instance
+         * @param {jQuery} $field Field element
+         * @param {Object} options Can consist of the following keys:
+         * - message: The invalid message
+         * @returns {Boolean}
+         */
+        validate: function(validator, $field, options) {
+            var value = $field.val();
+            if (value === '') {
+                return true;
+            }
+
+            // Groups are separated by a hyphen or a space
+            if (!/^\d{4}\-\d{3}[\dX]$/.test(value)) {
+                return false;
+            }
+
+            // Replace all special characters except digits and X
+            value = value.replace(/[^0-9X]/gi, '');
+            var chars  = value.split(''),
+                length = chars.length,
+                sum    = 0;
+
+            if (chars[7] === 'X') {
+                chars[7] = 10;
+            }
+            for (var i = 0; i < length; i++) {
+                sum += parseInt(chars[i], 10) * (8 - i);
+            }
+            return (sum % 11 === 0);
+        }
+    };
+}(window.jQuery));
+;(function($) {
+    $.fn.bootstrapValidator.i18n.lessThan = $.extend($.fn.bootstrapValidator.i18n.lessThan || {}, {
+        'default': 'Please enter a value less than or equal to %s',
+        notInclusive: 'Please enter a value less than %s'
+    });
+
+    $.fn.bootstrapValidator.validators.lessThan = {
+        html5Attributes: {
+            message: 'message',
+            value: 'value',
+            inclusive: 'inclusive'
+        },
+
+        enableByHtml5: function($field) {
+            var max = $field.attr('max');
+            if (max) {
+                return {
+                    value: max
+                };
+            }
+
+            return false;
+        },
+
+        /**
+         * Return true if the input value is less than or equal to given number
+         *
+         * @param {BootstrapValidator} validator The validator plugin instance
+         * @param {jQuery} $field Field element
+         * @param {Object} options Can consist of the following keys:
+         * - value: The number used to compare to. It can be
+         *      - A number
+         *      - Name of field which its value defines the number
+         *      - Name of callback function that returns the number
+         *      - A callback function that returns the number
+         *
+         * - inclusive [optional]: Can be true or false. Default is true
+         * - message: The invalid message
+         * @returns {Boolean|Object}
+         */
+        validate: function(validator, $field, options) {
+            var value = $field.val();
+            if (value === '') {
+                return true;
+            }
+
+            var compareTo = $.isNumeric(options.value) ? options.value : validator.getDynamicOption($field, options.value);
+
+            value = parseFloat(value);
+            return (options.inclusive === true || options.inclusive === undefined)
+                    ? {
+                        valid: value <= compareTo,
+                        message: $.fn.bootstrapValidator.helpers.format(options.message || $.fn.bootstrapValidator.i18n.lessThan['default'], compareTo)
+                    }
+                    : {
+                        valid: value < compareTo,
+                        message: $.fn.bootstrapValidator.helpers.format(options.message || $.fn.bootstrapValidator.i18n.lessThan.notInclusive, compareTo)
+                    };
+        }
+    };
+}(window.jQuery));
+;(function($) {
+    $.fn.bootstrapValidator.i18n.mac = $.extend($.fn.bootstrapValidator.i18n.mac || {}, {
+        'default': 'Please enter a valid MAC address'
+    });
+
+    $.fn.bootstrapValidator.validators.mac = {
+        /**
+         * Return true if the input value is a MAC address.
+         *
+         * @param {BootstrapValidator} validator The validator plugin instance
+         * @param {jQuery} $field Field element
+         * @param {Object} options Can consist of the following keys:
+         * - message: The invalid message
+         * @returns {Boolean}
+         */
+        validate: function(validator, $field, options) {
+            var value = $field.val();
+            if (value === '') {
+                return true;
+            }
+
+            return /^([0-9A-F]{2}[:-]){5}([0-9A-F]{2})$/.test(value);
+        }
+    };
+}(window.jQuery));
+;(function($) {
+    $.fn.bootstrapValidator.i18n.notEmpty = $.extend($.fn.bootstrapValidator.i18n.notEmpty || {}, {
+        'default': 'Please enter a value'
+    });
+
+    $.fn.bootstrapValidator.validators.notEmpty = {
+        enableByHtml5: function($field) {
+            var required = $field.attr('required') + '';
+            return ('required' === required || 'true' === required);
+        },
+
+        /**
+         * Check if input value is empty or not
+         *
+         * @param {BootstrapValidator} validator The validator plugin instance
+         * @param {jQuery} $field Field element
+         * @param {Object} options
+         * @returns {Boolean}
+         */
+        validate: function(validator, $field, options) {
+            var type = $field.attr('type');
+            if ('radio' === type || 'checkbox' === type) {
+                return validator
+                            .getFieldElements($field.attr('data-bv-field'))
+                            .filter(':checked')
+                            .length > 0;
+            }
+
+            return $.trim($field.val()) !== '';
+        }
+    };
+}(window.jQuery));
+;(function($) {
+    $.fn.bootstrapValidator.i18n.numeric = $.extend($.fn.bootstrapValidator.i18n.numeric || {}, {
+        'default': 'Please enter a valid float number'
+    });
+
+    $.fn.bootstrapValidator.validators.numeric = {
+        html5Attributes: {
+            message: 'message',
+            separator: 'separator'
+        },
+
+        enableByHtml5: function($field) {
+            return ('number' === $field.attr('type')) && ($field.attr('step') !== undefined) && ($field.attr('step') % 1 !== 0);
+        },
+
+        /**
+         * Validate decimal number
+         *
+         * @param {BootstrapValidator} validator The validator plugin instance
+         * @param {jQuery} $field Field element
+         * @param {Object} options Consist of key:
+         * - message: The invalid message
+         * - separator: The decimal separator. Can be "." (default), ","
+         * @returns {Boolean}
+         */
+        validate: function(validator, $field, options) {
+            var value = $field.val();
+            if (value === '') {
+                return true;
+            }
+            var separator = options.separator || '.';
+            if (separator !== '.') {
+                value = value.replace(separator, '.');
+            }
+
+            return !isNaN(parseFloat(value)) && isFinite(value);
+        }
+    };
+}(window.jQuery));
+;(function($) {
+    $.fn.bootstrapValidator.i18n.phone = $.extend($.fn.bootstrapValidator.i18n.phone || {}, {
+        'default': 'Please enter a valid phone number',
+        countryNotSupported: 'The country code %s is not supported',
+        country: 'Please enter a valid phone number in %s',
+        countries: {
+            GB: 'United Kingdom',
+            US: 'USA'
+        }
+    });
+
+    $.fn.bootstrapValidator.validators.phone = {
+        html5Attributes: {
+            message: 'message',
+            country: 'country'
+        },
+
+        // The supported countries
+        COUNTRY_CODES: ['GB', 'US'],
+
+        /**
+         * Return true if the input value contains a valid phone number for the country
+         * selected in the options
+         *
+         * @param {BootstrapValidator} validator Validate plugin instance
+         * @param {jQuery} $field Field element
+         * @param {Object} options Consist of key:
+         * - message: The invalid message
+         * - country: The ISO-3166 country code. It can be
+         *      - A country code
+         *      - Name of field which its value defines the country code
+         *      - Name of callback function that returns the country code
+         *      - A callback function that returns the country code
+         *
+         * Currently it only supports United State (US) or United Kingdom (GB) countries
+         * @returns {Boolean|Object}
+         */
+        validate: function(validator, $field, options) {
+            var value = $field.val();
+            if (value === '') {
+                return true;
+            }
+
+            var country = options.country;
+            if (typeof country !== 'string' || $.inArray(country, this.COUNTRY_CODES) === -1) {
+                // Try to determine the country
+                country = validator.getDynamicOption($field, country);
+            }
+
+            if (!country || $.inArray(country.toUpperCase(), this.COUNTRY_CODES) === -1) {
+                return {
+                    valid: false,
+                    message: $.fn.bootstrapValidator.helpers.format($.fn.bootstrapValidator.i18n.phone.countryNotSupported, country)
+                };
+            }
+
+            var isValid = true;
+            switch (country.toUpperCase()) {
+            	case 'GB':
+            		// http://aa-asterisk.org.uk/index.php/Regular_Expressions_for_Validating_and_Formatting_GB_Telephone_Numbers#Match_GB_telephone_number_in_any_format
+            		// Test: http://regexr.com/38uhv
+            		value   = $.trim(value);
+            		isValid = (/^\(?(?:(?:0(?:0|11)\)?[\s-]?\(?|\+)44\)?[\s-]?\(?(?:0\)?[\s-]?\(?)?|0)(?:\d{2}\)?[\s-]?\d{4}[\s-]?\d{4}|\d{3}\)?[\s-]?\d{3}[\s-]?\d{3,4}|\d{4}\)?[\s-]?(?:\d{5}|\d{3}[\s-]?\d{3})|\d{5}\)?[\s-]?\d{4,5}|8(?:00[\s-]?11[\s-]?11|45[\s-]?46[\s-]?4\d))(?:(?:[\s-]?(?:x|ext\.?\s?|\#)\d+)?)$/).test(value);
+                    break;
+
+                case 'US':
+                /* falls through */
+                default:
+                    // Make sure US phone numbers have 10 digits
+                    // May start with 1, +1, or 1-; should discard
+                    // Area code may be delimited with (), & sections may be delimited with . or -
+                    // Test: http://regexr.com/38mqi
+                    value   = value.replace(/\D/g, '');
+                    isValid = (/^(?:(1\-?)|(\+1 ?))?\(?(\d{3})[\)\-\.]?(\d{3})[\-\.]?(\d{4})$/).test(value) && (value.length === 10);
+                    break;
+            }
+
+            return {
+                valid: isValid,
+                message: $.fn.bootstrapValidator.helpers.format(options.message || $.fn.bootstrapValidator.i18n.phone.country, $.fn.bootstrapValidator.i18n.phone.countries[country])
+            };
+        }
+    };
+}(window.jQuery));
+;(function($) {
+    $.fn.bootstrapValidator.i18n.regexp = $.extend($.fn.bootstrapValidator.i18n.regexp || {}, {
+        'default': 'Please enter a value matching the pattern'
+    });
+
+    $.fn.bootstrapValidator.validators.regexp = {
+        html5Attributes: {
+            message: 'message',
+            regexp: 'regexp'
+        },
+
+        enableByHtml5: function($field) {
+            var pattern = $field.attr('pattern');
+            if (pattern) {
+                return {
+                    regexp: pattern
+                };
+            }
+
+            return false;
+        },
+
+        /**
+         * Check if the element value matches given regular expression
+         *
+         * @param {BootstrapValidator} validator The validator plugin instance
+         * @param {jQuery} $field Field element
+         * @param {Object} options Consists of the following key:
+         * - regexp: The regular expression you need to check
+         * @returns {Boolean}
+         */
+        validate: function(validator, $field, options) {
+            var value = $field.val();
+            if (value === '') {
+                return true;
+            }
+
+            var regexp = ('string' === typeof options.regexp) ? new RegExp(options.regexp) : options.regexp;
+            return regexp.test(value);
+        }
+    };
+}(window.jQuery));
+;(function($) {
+    $.fn.bootstrapValidator.i18n.remote = $.extend($.fn.bootstrapValidator.i18n.remote || {}, {
+        'default': 'Please enter a valid value'
+    });
+
+    $.fn.bootstrapValidator.validators.remote = {
+        html5Attributes: {
+            message: 'message',
+            url: 'url',
+            name: 'name'
+        },
+
+        /**
+         * Request a remote server to check the input value
+         *
+         * @param {BootstrapValidator} validator Plugin instance
+         * @param {jQuery} $field Field element
+         * @param {Object} options Can consist of the following keys:
+         * - url {String|Function}
+         * - type {String} [optional] Can be GET or POST (default)
+         * - data {Object|Function} [optional]: By default, it will take the value
+         *  {
+         *      <fieldName>: <fieldValue>
+         *  }
+         * - name {String} [optional]: Override the field name for the request.
+         * - message: The invalid message
+         * @returns {Boolean|Deferred}
+         */
+        validate: function(validator, $field, options) {
+            var value = $field.val();
+            if (value === '') {
+                return true;
+            }
+
+            var name = $field.attr('data-bv-field'),
+                data = options.data || {},
+                url  = options.url,
+                type = options.type || 'POST';
+
+            // Support dynamic data
+            if ('function' === typeof data) {
+                data = data.call(this, validator);
+            }
+
+            // Support dynamic url
+            if ('function' === typeof url) {
+                url = url.call(this, validator);
+            }
+
+            data[options.name || name] = value;
+
+            var dfd = new $.Deferred();
+            var xhr = $.ajax({
+                type: type,
+                url: url,
+                dataType: 'json',
+                data: data
+            });
+            xhr.then(function(response) {
+                dfd.resolve($field, 'remote', response.valid === true || response.valid === 'true', response.message ? response.message : null);
+            });
+
+            dfd.fail(function() {
+                xhr.abort();
+            });
+
+            return dfd;
+        }
+    };
+}(window.jQuery));
+;(function($) {
+    $.fn.bootstrapValidator.i18n.rtn = $.extend($.fn.bootstrapValidator.i18n.rtn || {}, {
+        'default': 'Please enter a valid RTN number'
+    });
+
+    $.fn.bootstrapValidator.validators.rtn = {
+        /**
+         * Validate a RTN (Routing transit number)
+         * Examples:
+         * - Valid: 021200025, 789456124
+         *
+         * @see http://en.wikipedia.org/wiki/Routing_transit_number
+         * @param {BootstrapValidator} validator The validator plugin instance
+         * @param {jQuery} $field Field element
+         * @param {Object} options Can consist of the following keys:
+         * - message: The invalid message
+         * @returns {Boolean}
+         */
+        validate: function(validator, $field, options) {
+            var value = $field.val();
+            if (value === '') {
+                return true;
+            }
+
+            if (!/^\d{9}$/.test(value)) {
+                return false;
+            }
+
+            var sum = 0;
+            for (var i = 0; i < value.length; i += 3) {
+                sum += parseInt(value.charAt(i),     10) * 3
+                    +  parseInt(value.charAt(i + 1), 10) * 7
+                    +  parseInt(value.charAt(i + 2), 10);
+            }
+            return (sum !== 0 && sum % 10 === 0);
+        }
+    };
+}(window.jQuery));
+;(function($) {
+    $.fn.bootstrapValidator.i18n.sedol = $.extend($.fn.bootstrapValidator.i18n.sedol || {}, {
+        'default': 'Please enter a valid SEDOL number'
+    });
+
+    $.fn.bootstrapValidator.validators.sedol = {
+        /**
+         * Validate a SEDOL (Stock Exchange Daily Official List)
+         * Examples:
+         * - Valid: 0263494, B0WNLY7
+         *
+         * @see http://en.wikipedia.org/wiki/SEDOL
+         * @param {BootstrapValidator} validator The validator plugin instance
+         * @param {jQuery} $field Field element
+         * @param {Object} options Can consist of the following keys:
+         * - message: The invalid message
+         * @returns {Boolean}
+         */
+        validate: function(validator, $field, options) {
+            var value = $field.val();
+            if (value === '') {
+                return true;
+            }
+
+            value = value.toUpperCase();
+            if (!/^[0-9A-Z]{7}$/.test(value)) {
+                return false;
+            }
+
+            var sum    = 0,
+                weight = [1, 3, 1, 7, 3, 9, 1],
+                length = value.length;
+            for (var i = 0; i < length - 1; i++) {
+	            sum += weight[i] * parseInt(value.charAt(i), 36);
+	        }
+	        sum = (10 - sum % 10) % 10;
+            return sum + '' === value.charAt(length - 1);
+        }
+    };
+}(window.jQuery));
+;(function($) {
+    $.fn.bootstrapValidator.i18n.siren = $.extend($.fn.bootstrapValidator.i18n.siren || {}, {
+        'default': 'Please enter a valid SIREN number'
+    });
+
+	$.fn.bootstrapValidator.validators.siren = {
+		/**
+		 * Check if a string is a siren number
+		 *
+		 * @param {BootstrapValidator} validator The validator plugin instance
+		 * @param {jQuery} $field Field element
+		 * @param {Object} options Consist of key:
+         * - message: The invalid message
+		 * @returns {Boolean}
+		 */
+		validate: function(validator, $field, options) {
+			var value = $field.val();
+			if (value === '') {
+				return true;
+			}
+
+            if (!/^\d{9}$/.test(value)) {
+                return false;
+            }
+            return $.fn.bootstrapValidator.helpers.luhn(value);
+		}
+	};
+}(window.jQuery));
+;(function($) {
+    $.fn.bootstrapValidator.i18n.siret = $.extend($.fn.bootstrapValidator.i18n.siret || {}, {
+        'default': 'Please enter a valid SIRET number'
+    });
+
+	$.fn.bootstrapValidator.validators.siret = {
+        /**
+         * Check if a string is a siret number
+         *
+         * @param {BootstrapValidator} validator The validator plugin instance
+         * @param {jQuery} $field Field element
+         * @param {Object} options Consist of key:
+         * - message: The invalid message
+         * @returns {Boolean}
+         */
+		validate: function(validator, $field, options) {
+			var value = $field.val();
+			if (value === '') {
+				return true;
+			}
+
+			var sum    = 0,
+                length = value.length,
+                tmp;
+			for (var i = 0; i < length; i++) {
+                tmp = parseInt(value.charAt(i), 10);
+				if ((i % 2) === 0) {
+					tmp = tmp * 2;
+					if (tmp > 9) {
+						tmp -= 9;
+					}
+				}
+				sum += tmp;
+			}
+			return (sum % 10 === 0);
+		}
+	};
+}(window.jQuery));
+;(function($) {
+    $.fn.bootstrapValidator.i18n.step = $.extend($.fn.bootstrapValidator.i18n.step || {}, {
+        'default': 'Please enter a valid step of %s'
+    });
+
+    $.fn.bootstrapValidator.validators.step = {
+        html5Attributes: {
+            message: 'message',
+            base: 'baseValue',
+            step: 'step'
+        },
+
+        /**
+         * Return true if the input value is valid step one
+         *
+         * @param {BootstrapValidator} validator The validator plugin instance
+         * @param {jQuery} $field Field element
+         * @param {Object} options Can consist of the following keys:
+         * - baseValue: The base value
+         * - step: The step
+         * - message: The invalid message
+         * @returns {Boolean|Object}
+         */
+        validate: function(validator, $field, options) {
+            var value = $field.val();
+            if (value === '') {
+                return true;
+            }
+
+            options = $.extend({}, { baseValue: 0, step: 1 }, options);
+            value   = parseFloat(value);
+            if (!$.isNumeric(value)) {
+                return false;
+            }
+
+            var round = function(x, precision) {
+                    var m = Math.pow(10, precision);
+                    x = x * m;
+                    var sign   = (x > 0) | -(x < 0),
+                        isHalf = (x % 1 === 0.5 * sign);
+                    if (isHalf) {
+                        return (Math.floor(x) + (sign > 0)) / m;
+                    } else {
+                        return Math.round(x) / m;
+                    }
+                },
+                floatMod = function(x, y) {
+                    if (y === 0.0) {
+                        return 1.0;
+                    }
+                    var dotX      = (x + '').split('.'),
+                        dotY      = (y + '').split('.'),
+                        precision = ((dotX.length === 1) ? 0 : dotX[1].length) + ((dotY.length === 1) ? 0 : dotY[1].length);
+                    return round(x - y * Math.floor(x / y), precision);
+                };
+
+            var mod = floatMod(value - options.baseValue, options.step);
+            return {
+                valid: mod === 0.0 || mod === options.step,
+                message: $.fn.bootstrapValidator.helpers.format(options.message || $.fn.bootstrapValidator.i18n.step['default'], [options.step])
+            };
+        }
+    };
+}(window.jQuery));
+;(function($) {
+    $.fn.bootstrapValidator.i18n.stringCase = $.extend($.fn.bootstrapValidator.i18n.stringCase || {}, {
+        'default': 'Please enter only lowercase characters',
+        upper: 'Please enter only uppercase characters'
+    });
+
+    $.fn.bootstrapValidator.validators.stringCase = {
+        html5Attributes: {
+            message: 'message',
+            'case': 'case'
+        },
+
+        /**
+         * Check if a string is a lower or upper case one
+         *
+         * @param {BootstrapValidator} validator The validator plugin instance
+         * @param {jQuery} $field Field element
+         * @param {Object} options Consist of key:
+         * - message: The invalid message
+         * - case: Can be 'lower' (default) or 'upper'
+         * @returns {Object}
+         */
+        validate: function(validator, $field, options) {
+            var value = $field.val();
+            if (value === '') {
+                return true;
+            }
+
+            var stringCase = (options['case'] || 'lower').toLowerCase();
+            return {
+                valid: ('upper' === stringCase) ? value === value.toUpperCase() : value === value.toLowerCase(),
+                message: options.message || (('upper' === stringCase) ? $.fn.bootstrapValidator.i18n.stringCase.upper : $.fn.bootstrapValidator.i18n.stringCase['default'])
+            };
+        }
+    };
+}(window.jQuery));
+;(function($) {
+    $.fn.bootstrapValidator.i18n.stringLength = $.extend($.fn.bootstrapValidator.i18n.stringLength || {}, {
+        'default': 'Please enter a value with valid length',
+        less: 'Please enter less than %s characters',
+        more: 'Please enter more than %s characters',
+        between: 'Please enter value between %s and %s characters long'
+    });
+
+    $.fn.bootstrapValidator.validators.stringLength = {
+        html5Attributes: {
+            message: 'message',
+            min: 'min',
+            max: 'max'
+        },
+
+        enableByHtml5: function($field) {
+            var maxLength = $field.attr('maxlength');
+            if (maxLength) {
+                return {
+                    max: parseInt(maxLength, 10)
+                };
+            }
+
+            return false;
+        },
+
+        /**
+         * Check if the length of element value is less or more than given number
+         *
+         * @param {BootstrapValidator} validator The validator plugin instance
+         * @param {jQuery} $field Field element
+         * @param {Object} options Consists of following keys:
+         * - min
+         * - max
+         * At least one of two keys is required
+         * The min, max keys define the number which the field value compares to. min, max can be
+         *      - A number
+         *      - Name of field which its value defines the number
+         *      - Name of callback function that returns the number
+         *      - A callback function that returns the number
+         *
+         * - message: The invalid message
+         * @returns {Object}
+         */
+        validate: function(validator, $field, options) {
+            var value = $field.val();
+            if (value === '') {
+                return true;
+            }
+
+            var min     = $.isNumeric(options.min) ? options.min : validator.getDynamicOption($field, options.min),
+                max     = $.isNumeric(options.max) ? options.max : validator.getDynamicOption($field, options.max),
+                length  = value.length,
+                isValid = true,
+                message = options.message || $.fn.bootstrapValidator.i18n.stringLength['default'];
+
+            if ((min && length < parseInt(min, 10)) || (max && length > parseInt(max, 10))) {
+                isValid = false;
+            }
+
+            switch (true) {
+                case (!!min && !!max):
+                    message = $.fn.bootstrapValidator.helpers.format(options.message || $.fn.bootstrapValidator.i18n.stringLength.between, [parseInt(min, 10), parseInt(max, 10)]);
+                    break;
+
+                case (!!min):
+                    message = $.fn.bootstrapValidator.helpers.format(options.message || $.fn.bootstrapValidator.i18n.stringLength.more, parseInt(min, 10));
+                    break;
+
+                case (!!max):
+                    message = $.fn.bootstrapValidator.helpers.format(options.message || $.fn.bootstrapValidator.i18n.stringLength.less, parseInt(max, 10));
+                    break;
+
+                default:
+                    break;
+            }
+
+            return { valid: isValid, message: message };
+        }
+    };
+}(window.jQuery));
+;(function($) {
+    $.fn.bootstrapValidator.i18n.uri = $.extend($.fn.bootstrapValidator.i18n.uri || {}, {
+        'default': 'Please enter a valid URI'
+    });
+
+    $.fn.bootstrapValidator.validators.uri = {
+        html5Attributes: {
+            message: 'message',
+            allowlocal: 'allowLocal'
+        },
+
+        enableByHtml5: function($field) {
+            return ('url' === $field.attr('type'));
+        },
+
+        /**
+         * Return true if the input value is a valid URL
+         *
+         * @param {BootstrapValidator} validator The validator plugin instance
+         * @param {jQuery} $field Field element
+         * @param {Object} options
+         * - message: The error message
+         * - allowLocal: Allow the private and local network IP. Default to false
+         * @returns {Boolean}
+         */
+        validate: function(validator, $field, options) {
+            var value = $field.val();
+            if (value === '') {
+                return true;
+            }
+
+            // Credit to https://gist.github.com/dperini/729294
+            //
+            // Regular Expression for URL validation
+            //
+            // Author: Diego Perini
+            // Updated: 2010/12/05
+            //
+            // the regular expression composed & commented
+            // could be easily tweaked for RFC compliance,
+            // it was expressly modified to fit & satisfy
+            // these test for an URL shortener:
+            //
+            //   http://mathiasbynens.be/demo/url-regex
+            //
+            // Notes on possible differences from a standard/generic validation:
+            //
+            // - utf-8 char class take in consideration the full Unicode range
+            // - TLDs have been made mandatory so single names like "localhost" fails
+            // - protocols have been restricted to ftp, http and https only as requested
+            //
+            // Changes:
+            //
+            // - IP address dotted notation validation, range: 1.0.0.0 - 223.255.255.255
+            //   first and last IP address of each class is considered invalid
+            //   (since they are broadcast/network addresses)
+            //
+            // - Added exclusion of private, reserved and/or local networks ranges
+            //
+            var allowLocal = options.allowLocal === true || options.allowLocal === 'true',
+                urlExp     = new RegExp(
+                    "^" +
+                    // protocol identifier
+                    "(?:(?:https?|ftp)://)" +
+                    // user:pass authentication
+                    "(?:\\S+(?::\\S*)?@)?" +
+                    "(?:" +
+                    // IP address exclusion
+                    // private & local networks
+                    (allowLocal
+                        ? ''
+                        : ("(?!(?:10|127)(?:\\.\\d{1,3}){3})" +
+                           "(?!(?:169\\.254|192\\.168)(?:\\.\\d{1,3}){2})" +
+                           "(?!172\\.(?:1[6-9]|2\\d|3[0-1])(?:\\.\\d{1,3}){2})")) +
+                    // IP address dotted notation octets
+                    // excludes loopback network 0.0.0.0
+                    // excludes reserved space >= 224.0.0.0
+                    // excludes network & broadcast addresses
+                    // (first & last IP address of each class)
+                    "(?:[1-9]\\d?|1\\d\\d|2[01]\\d|22[0-3])" +
+                    "(?:\\.(?:1?\\d{1,2}|2[0-4]\\d|25[0-5])){2}" +
+                    "(?:\\.(?:[1-9]\\d?|1\\d\\d|2[0-4]\\d|25[0-4]))" +
+                    "|" +
+                    // host name
+                    "(?:(?:[a-z\\u00a1-\\uffff0-9]+-?)*[a-z\\u00a1-\\uffff0-9]+)" +
+                    // domain name
+                    "(?:\\.(?:[a-z\\u00a1-\\uffff0-9]+-?)*[a-z\\u00a1-\\uffff0-9]+)*" +
+                    // TLD identifier
+                    "(?:\\.(?:[a-z\\u00a1-\\uffff]{2,}))" +
+                    ")" +
+                    // port number
+                    "(?::\\d{2,5})?" +
+                    // resource path
+                    "(?:/[^\\s]*)?" +
+                    "$", "i"
+                );
+
+            return urlExp.test(value);
+        }
+    };
+}(window.jQuery));
+;(function($) {
+    $.fn.bootstrapValidator.i18n.uuid = $.extend($.fn.bootstrapValidator.i18n.uuid || {}, {
+        'default': 'Please enter a valid UUID number',
+        version: 'Please enter a valid UUID version %s number'
+    });
+
+    $.fn.bootstrapValidator.validators.uuid = {
+        html5Attributes: {
+            message: 'message',
+            version: 'version'
+        },
+
+        /**
+         * Return true if and only if the input value is a valid UUID string
+         *
+         * @see http://en.wikipedia.org/wiki/Universally_unique_identifier
+         * @param {BootstrapValidator} validator The validator plugin instance
+         * @param {jQuery} $field Field element
+         * @param {Object} options Consist of key:
+         * - message: The invalid message
+         * - version: Can be 3, 4, 5, null
+         * @returns {Boolean|Object}
+         */
+        validate: function(validator, $field, options) {
+            var value = $field.val();
+            if (value === '') {
+                return true;
+            }
+
+            // See the format at http://en.wikipedia.org/wiki/Universally_unique_identifier#Variants_and_versions
+            var patterns = {
+                    '3': /^[0-9A-F]{8}-[0-9A-F]{4}-3[0-9A-F]{3}-[0-9A-F]{4}-[0-9A-F]{12}$/i,
+                    '4': /^[0-9A-F]{8}-[0-9A-F]{4}-4[0-9A-F]{3}-[89AB][0-9A-F]{3}-[0-9A-F]{12}$/i,
+                    '5': /^[0-9A-F]{8}-[0-9A-F]{4}-5[0-9A-F]{3}-[89AB][0-9A-F]{3}-[0-9A-F]{12}$/i,
+                    all: /^[0-9A-F]{8}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{12}$/i
+                },
+                version = options.version ? (options.version + '') : 'all';
+            return {
+                valid: (null === patterns[version]) ? true : patterns[version].test(value),
+                message: options.version
+                            ? $.fn.bootstrapValidator.helpers.format(options.message || $.fn.bootstrapValidator.i18n.uuid.version, options.version)
+                            : (options.message || $.fn.bootstrapValidator.i18n.uuid['default'])
+            };
+        }
+    };
+}(window.jQuery));
+;(function($) {
+    $.fn.bootstrapValidator.i18n.vat = $.extend($.fn.bootstrapValidator.i18n.vat || {}, {
+        'default': 'Please enter a valid VAT number',
+        countryNotSupported: 'The country code %s is not supported',
+        country: 'Please enter a valid %s VAT number',
+        countries: {
+            AT: 'Austrian',
+            BE: 'Belgian',
+            BG: 'Bulgarian',
+            CH: 'Swiss',
+            CY: 'Cypriot',
+            CZ: 'Czech',
+            DE: 'German',
+            DK: 'Danish',
+            EE: 'Estonian',
+            ES: 'Spanish',
+            FI: 'Finnish',
+            FR: 'French',
+            GB: 'United Kingdom',
+            GR: 'Greek',
+            EL: 'Greek',
+            HU: 'Hungarian',
+            HR: 'Croatian',
+            IE: 'Irish',
+            IT: 'Italian',
+            LT: 'Lithuanian',
+            LU: 'Luxembourg',
+            LV: 'Latvian',
+            MT: 'Maltese',
+            NL: 'Dutch',
+            NO: 'Norwegian',
+            PL: 'Polish',
+            PT: 'Portuguese',
+            RO: 'Romanian',
+            RU: 'Russian',
+            RS: 'Serbian',
+            SE: 'Swedish',
+            SI: 'Slovenian',
+            SK: 'Slovak'
+        }
+    });
+
+    $.fn.bootstrapValidator.validators.vat = {
+        html5Attributes: {
+            message: 'message',
+            country: 'country'
+        },
+
+        // Supported country codes
+        COUNTRY_CODES: [
+            'AT', 'BE', 'BG', 'HR', 'CY', 'CZ', 'DK', 'EE', 'FI', 'FR', 'DE', 'GR', 'EL', 'HU', 'IE', 'IT',
+            'LV', 'LT', 'LU', 'MT', 'NL', 'NO', 'PL', 'PT', 'RO', 'RU', 'RS', 'SK', 'SI', 'ES', 'SE', 'CH', 'GB'
+        ],
+
+        /**
+         * Validate an European VAT number
+         *
+         * @param {BootstrapValidator} validator The validator plugin instance
+         * @param {jQuery} $field Field element
+         * @param {Object} options Consist of key:
+         * - message: The invalid message
+         * - country: The ISO 3166-1 country code. It can be
+         *      - One of country code defined in COUNTRY_CODES
+         *      - Name of field which its value defines the country code
+         *      - Name of callback function that returns the country code
+         *      - A callback function that returns the country code
+         * @returns {Boolean|Object}
+         */
+        validate: function(validator, $field, options) {
+            var value = $field.val();
+            if (value === '') {
+                return true;
+            }
+
+            var country = options.country;
+            if (!country) {
+                country = value.substr(0, 2);
+            } else if (typeof country !== 'string' || $.inArray(country.toUpperCase(), this.COUNTRY_CODES) === -1) {
+                // Determine the country code
+                country = validator.getDynamicOption($field, country);
+            }
+
+            if ($.inArray(country, this.COUNTRY_CODES) === -1) {
+                return {
+                    valid: false,
+                    message: $.fn.bootstrapValidator.helpers.format($.fn.bootstrapValidator.i18n.vat.countryNotSupported, country)
+                };
+            }
+
+            var method  = ['_', country.toLowerCase()].join('');
+            return this[method](value)
+                ? true
+                : {
+                    valid: false,
+                    message: $.fn.bootstrapValidator.helpers.format(options.message || $.fn.bootstrapValidator.i18n.vat.country, $.fn.bootstrapValidator.i18n.vat.countries[country.toUpperCase()])
+                };
+        },
+
+        // VAT validators
+
+        /**
+         * Validate Austrian VAT number
+         * Example:
+         * - Valid: ATU13585627
+         * - Invalid: ATU13585626
+         *
+         * @param {String} value VAT number
+         * @returns {Boolean}
+         */
+        _at: function(value) {
+            if (!/^ATU[0-9]{8}$/.test(value)) {
+                return false;
+            }
+
+            value = value.substr(3);
+            var sum    = 0,
+                weight = [1, 2, 1, 2, 1, 2, 1],
+                temp   = 0;
+
+            for (var i = 0; i < 7; i++) {
+                temp = parseInt(value.charAt(i), 10) * weight[i];
+                if (temp > 9) {
+                    temp = Math.floor(temp / 10) + temp % 10;
+                }
+                sum += temp;
+            }
+
+            sum = 10 - (sum + 4) % 10;
+            if (sum === 10) {
+                sum = 0;
+            }
+
+            return (sum + '' === value.substr(7, 1));
+        },
+
+        /**
+         * Validate Belgian VAT number
+         * Example:
+         * - Valid: BE0428759497
+         * - Invalid: BE431150351
+         *
+         * @param {String} value VAT number
+         * @returns {Boolean}
+         */
+        _be: function(value) {
+            if (!/^BE[0]{0,1}[0-9]{9}$/.test(value)) {
+                return false;
+            }
+
+            value = value.substr(2);
+            if (value.length === 9) {
+                value = '0' + value;
+            }
+
+            if (value.substr(1, 1) === '0') {
+                return false;
+            }
+
+            var sum = parseInt(value.substr(0, 8), 10) + parseInt(value.substr(8, 2), 10);
+            return (sum % 97 === 0);
+        },
+
+        /**
+         * Validate Bulgarian VAT number
+         * Example:
+         * - Valid: BG175074752,
+         * BG7523169263, BG8032056031,
+         * BG7542011030,
+         * BG7111042925
+         * - Invalid: BG175074753, BG7552A10004, BG7111042922
+         *
+         * @param {String} value VAT number
+         * @returns {Boolean}
+         */
+        _bg: function(value) {
+            if (!/^BG[0-9]{9,10}$/.test(value)) {
+                return false;
+            }
+
+            value = value.substr(2);
+            var sum = 0, i = 0;
+
+            // Legal entities
+            if (value.length === 9) {
+                for (i = 0; i < 8; i++) {
+                    sum += parseInt(value.charAt(i), 10) * (i + 1);
+                }
+                sum = sum % 11;
+                if (sum === 10) {
+                    sum = 0;
+                    for (i = 0; i < 8; i++) {
+                        sum += parseInt(value.charAt(i), 10) * (i + 3);
+                    }
+                }
+                sum = sum % 10;
+                return (sum + '' === value.substr(8));
+            }
+            // Physical persons, foreigners and others
+            else if (value.length === 10) {
+                // Validate Bulgarian national identification numbers
+                var egn = function(value) {
+                        // Check the birth date
+                        var year  = parseInt(value.substr(0, 2), 10) + 1900,
+                            month = parseInt(value.substr(2, 2), 10),
+                            day   = parseInt(value.substr(4, 2), 10);
+                        if (month > 40) {
+                            year += 100;
+                            month -= 40;
+                        } else if (month > 20) {
+                            year -= 100;
+                            month -= 20;
+                        }
+
+                        if (!$.fn.bootstrapValidator.helpers.date(year, month, day)) {
+                            return false;
+                        }
+
+                        var sum    = 0,
+                            weight = [2, 4, 8, 5, 10, 9, 7, 3, 6];
+                        for (var i = 0; i < 9; i++) {
+                            sum += parseInt(value.charAt(i), 10) * weight[i];
+                        }
+                        sum = (sum % 11) % 10;
+                        return (sum + '' === value.substr(9, 1));
+                    },
+                    // Validate Bulgarian personal number of a foreigner
+                    pnf = function(value) {
+                        var sum    = 0,
+                            weight = [21, 19, 17, 13, 11, 9, 7, 3, 1];
+                        for (var i = 0; i < 9; i++) {
+                            sum += parseInt(value.charAt(i), 10) * weight[i];
+                        }
+                        sum = sum % 10;
+                        return (sum + '' === value.substr(9, 1));
+                    },
+                    // Finally, consider it as a VAT number
+                    vat = function(value) {
+                        var sum    = 0,
+                            weight = [4, 3, 2, 7, 6, 5, 4, 3, 2];
+                        for (var i = 0; i < 9; i++) {
+                            sum += parseInt(value.charAt(i), 10) * weight[i];
+                        }
+                        sum = 11 - sum % 11;
+                        if (sum === 10) {
+                            return false;
+                        }
+                        if (sum === 11) {
+                            sum = 0;
+                        }
+                        return (sum + '' === value.substr(9, 1));
+                    };
+                return (egn(value) || pnf(value) || vat(value));
+            }
+
+            return false;
+        },
+
+        /**
+         * Validate Swiss VAT number
+         *
+         * @param {String} value VAT number
+         * @returns {Boolean}
+         */
+        _ch: function(value) {
+            if (!/^CHE[0-9]{9}(MWST)?$/.test(value)) {
+                return false;
+            }
+
+            value = value.substr(3);
+            var sum    = 0,
+                weight = [5, 4, 3, 2, 7, 6, 5, 4];
+            for (var i = 0; i < 8; i++) {
+                sum += parseInt(value.charAt(i), 10) * weight[i];
+            }
+
+            sum = 11 - sum % 11;
+            if (sum === 10) {
+                return false;
+            }
+            if (sum === 11) {
+                sum = 0;
+            }
+
+            return (sum + '' === value.substr(8, 1));
+        },
+
+        /**
+         * Validate Cypriot VAT number
+         * Examples:
+         * - Valid: CY10259033P
+         * - Invalid: CY10259033Z
+         *
+         * @param {String} value VAT number
+         * @returns {Boolean}
+         */
+        _cy: function(value) {
+            if (!/^CY[0-5|9]{1}[0-9]{7}[A-Z]{1}$/.test(value)) {
+                return false;
+            }
+
+            value = value.substr(2);
+
+            // Do not allow to start with "12"
+            if (value.substr(0, 2) === '12') {
+                return false;
+            }
+
+            // Extract the next digit and multiply by the counter.
+            var sum         = 0,
+                translation = {
+                    '0': 1,  '1': 0,  '2': 5,  '3': 7,  '4': 9,
+                    '5': 13, '6': 15, '7': 17, '8': 19, '9': 21
+                };
+            for (var i = 0; i < 8; i++) {
+                var temp = parseInt(value.charAt(i), 10);
+                if (i % 2 === 0) {
+                    temp = translation[temp + ''];
+                }
+                sum += temp;
+            }
+
+            sum = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'[sum % 26];
+            return (sum + '' === value.substr(8, 1));
+        },
+
+        /**
+         * Validate Czech Republic VAT number
+         * Can be:
+         * i) Legal entities (8 digit numbers)
+         * ii) Individuals with a RC (the 9 or 10 digit Czech birth number)
+         * iii) Individuals without a RC (9 digit numbers beginning with 6)
+         *
+         * Examples:
+         * - Valid: i) CZ25123891; ii) CZ7103192745, CZ991231123; iii) CZ640903926
+         * - Invalid: i) CZ25123890; ii) CZ1103492745, CZ590312123
+         *
+         * @param {String} value VAT number
+         * @returns {Boolean}
+         */
+        _cz: function(value) {
+            if (!/^CZ[0-9]{8,10}$/.test(value)) {
+                return false;
+            }
+
+            value = value.substr(2);
+
+            var sum = 0,
+                i   = 0;
+            if (value.length === 8) {
+                // Do not allow to start with '9'
+                if (value.charAt(0) + '' === '9') {
+                    return false;
+                }
+
+                sum = 0;
+                for (i = 0; i < 7; i++) {
+                    sum += parseInt(value.charAt(i), 10) * (8 - i);
+                }
+                sum = 11 - sum % 11;
+                if (sum === 10) {
+                    sum = 0;
+                }
+                if (sum === 11) {
+                    sum = 1;
+                }
+
+                return (sum + '' === value.substr(7, 1));
+            } else if (value.length === 9 && (value.charAt(0) + '' === '6')) {
+                sum = 0;
+                // Skip the first (which is 6)
+                for (i = 0; i < 7; i++) {
+                    sum += parseInt(value.charAt(i + 1), 10) * (8 - i);
+                }
+                sum = 11 - sum % 11;
+                if (sum === 10) {
+                    sum = 0;
+                }
+                if (sum === 11) {
+                    sum = 1;
+                }
+                sum = [8, 7, 6, 5, 4, 3, 2, 1, 0, 9, 10][sum - 1];
+                return (sum + '' === value.substr(8, 1));
+            } else if (value.length === 9 || value.length === 10) {
+                // Validate Czech birth number (Rodné číslo), which is also national identifier
+                var year  = 1900 + parseInt(value.substr(0, 2), 10),
+                    month = parseInt(value.substr(2, 2), 10) % 50 % 20,
+                    day   = parseInt(value.substr(4, 2), 10);
+                if (value.length === 9) {
+                    if (year >= 1980) {
+                        year -= 100;
+                    }
+                    if (year > 1953) {
+                        return false;
+                    }
+                } else if (year < 1954) {
+                    year += 100;
+                }
+
+                if (!$.fn.bootstrapValidator.helpers.date(year, month, day)) {
+                    return false;
+                }
+
+                // Check that the birth date is not in the future
+                if (value.length === 10) {
+                    var check = parseInt(value.substr(0, 9), 10) % 11;
+                    if (year < 1985) {
+                        check = check % 10;
+                    }
+                    return (check + '' === value.substr(9, 1));
+                }
+
+                return true;
+            }
+
+            return false;
+        },
+
+        /**
+         * Validate German VAT number
+         * Examples:
+         * - Valid: DE136695976
+         * - Invalid: DE136695978
+         *
+         * @param {String} value VAT number
+         * @returns {Boolean}
+         */
+        _de: function(value) {
+            if (!/^DE[0-9]{9}$/.test(value)) {
+                return false;
+            }
+
+            value = value.substr(2);
+            return $.fn.bootstrapValidator.helpers.mod11And10(value);
+        },
+
+        /**
+         * Validate Danish VAT number
+         * Example:
+         * - Valid: DK13585628
+         * - Invalid: DK13585627
+         *
+         * @param {String} value VAT number
+         * @returns {Boolean}
+         */
+        _dk: function(value) {
+            if (!/^DK[0-9]{8}$/.test(value)) {
+                return false;
+            }
+
+            value = value.substr(2);
+            var sum    = 0,
+                weight = [2, 7, 6, 5, 4, 3, 2, 1];
+            for (var i = 0; i < 8; i++) {
+                sum += parseInt(value.charAt(i), 10) * weight[i];
+            }
+
+            return (sum % 11 === 0);
+        },
+
+        /**
+         * Validate Estonian VAT number
+         * Examples:
+         * - Valid: EE100931558, EE100594102
+         * - Invalid: EE100594103
+         *
+         * @param {String} value VAT number
+         * @returns {Boolean}
+         */
+        _ee: function(value) {
+            if (!/^EE[0-9]{9}$/.test(value)) {
+                return false;
+            }
+
+            value = value.substr(2);
+            var sum    = 0,
+                weight = [3, 7, 1, 3, 7, 1, 3, 7, 1];
+
+            for (var i = 0; i < 9; i++) {
+                sum += parseInt(value.charAt(i), 10) * weight[i];
+            }
+
+            return (sum % 10 === 0);
+        },
+
+        /**
+         * Validate Spanish VAT number (NIF - Número de Identificación Fiscal)
+         * Can be:
+         * i) DNI (Documento nacional de identidad), for Spaniards
+         * ii) NIE (Número de Identificación de Extranjeros), for foreigners
+         * iii) CIF (Certificado de Identificación Fiscal), for legal entities and others
+         *
+         * Examples:
+         * - Valid: i) ES54362315K; ii) ESX2482300W, ESX5253868R; iii) ESM1234567L, ESJ99216582, ESB58378431, ESB64717838
+         * - Invalid: i) ES54362315Z; ii) ESX2482300A; iii) ESJ99216583
+         *
+         * @param {String} value VAT number
+         * @returns {Boolean}
+         */
+        _es: function(value) {
+            if (!/^ES[0-9A-Z][0-9]{7}[0-9A-Z]$/.test(value)) {
+                return false;
+            }
+
+            value = value.substr(2);
+            var dni = function(value) {
+                    var check = parseInt(value.substr(0, 8), 10);
+                    check = 'TRWAGMYFPDXBNJZSQVHLCKE'[check % 23];
+                    return (check + '' === value.substr(8, 1));
+                },
+                nie = function(value) {
+                    var check = ['XYZ'.indexOf(value.charAt(0)), value.substr(1)].join('');
+                    check = parseInt(check, 10);
+                    check = 'TRWAGMYFPDXBNJZSQVHLCKE'[check % 23];
+                    return (check + '' === value.substr(8, 1));
+                },
+                cif = function(value) {
+                    var first = value.charAt(0), check;
+                    if ('KLM'.indexOf(first) !== -1) {
+                        // K: Spanish younger than 14 year old
+                        // L: Spanish living outside Spain without DNI
+                        // M: Granted the tax to foreigners who have no NIE
+                        check = parseInt(value.substr(1, 8), 10);
+                        check = 'TRWAGMYFPDXBNJZSQVHLCKE'[check % 23];
+                        return (check + '' === value.substr(8, 1));
+                    } else if ('ABCDEFGHJNPQRSUVW'.indexOf(first) !== -1) {
+                        var sum    = 0,
+                            weight = [2, 1, 2, 1, 2, 1, 2],
+                            temp   = 0;
+
+                        for (var i = 0; i < 7; i++) {
+                            temp = parseInt(value.charAt(i + 1), 10) * weight[i];
+                            if (temp > 9) {
+                                temp = Math.floor(temp / 10) + temp % 10;
+                            }
+                            sum += temp;
+                        }
+                        sum = 10 - sum % 10;
+                        return (sum + '' === value.substr(8, 1) || 'JABCDEFGHI'[sum] === value.substr(8, 1));
+                    }
+
+                    return false;
+                };
+
+            var first = value.charAt(0);
+            if (/^[0-9]$/.test(first)) {
+                return dni(value);
+            } else if (/^[XYZ]$/.test(first)) {
+                return nie(value);
+            } else {
+                return cif(value);
+            }
+        },
+
+        /**
+         * Validate Finnish VAT number
+         * Examples:
+         * - Valid: FI20774740
+         * - Invalid: FI20774741
+         *
+         * @param {String} value VAT number
+         * @returns {Boolean}
+         */
+        _fi: function(value) {
+            if (!/^FI[0-9]{8}$/.test(value)) {
+                return false;
+            }
+
+            value = value.substr(2);
+            var sum    = 0,
+                weight = [7, 9, 10, 5, 8, 4, 2, 1];
+
+            for (var i = 0; i < 8; i++) {
+                sum += parseInt(value.charAt(i), 10) * weight[i];
+            }
+
+            return (sum % 11 === 0);
+        },
+
+        /**
+         * Validate French VAT number (TVA - taxe sur la valeur ajoutée)
+         * It's constructed by a SIREN number, prefixed by two characters.
+         *
+         * Examples:
+         * - Valid: FR40303265045, FR23334175221, FRK7399859412, FR4Z123456782
+         * - Invalid: FR84323140391
+         *
+         * @param {String} value VAT number
+         * @returns {Boolean}
+         */
+        _fr: function(value) {
+            if (!/^FR[0-9A-Z]{2}[0-9]{9}$/.test(value)) {
+                return false;
+            }
+
+            value = value.substr(2);
+
+			if (!$.fn.bootstrapValidator.helpers.luhn(value.substr(2))) {
+                return false;
+            }
+
+            if (/^[0-9]{2}$/.test(value.substr(0, 2))) {
+                // First two characters are digits
+                return value.substr(0, 2) === (parseInt(value.substr(2) + '12', 10) % 97 + '');
+            } else {
+                // The first characters cann't be O and I
+                var alphabet = '0123456789ABCDEFGHJKLMNPQRSTUVWXYZ',
+                    check;
+                // First one is digit
+                if (/^[0-9]{1}$/.test(value.charAt(0))) {
+                    check = alphabet.indexOf(value.charAt(0)) * 24 + alphabet.indexOf(value.charAt(1)) - 10;
+                } else {
+                    check = alphabet.indexOf(value.charAt(0)) * 34 + alphabet.indexOf(value.charAt(1)) - 100;
+                }
+                return ((parseInt(value.substr(2), 10) + 1 + Math.floor(check / 11)) % 11) === (check % 11);
+            }
+        },
+
+        /**
+         * Validate United Kingdom VAT number
+         * Example:
+         * - Valid: GB980780684
+         * - Invalid: GB802311781
+         *
+         * @param {String} value VAT number
+         * @returns {Boolean}
+         */
+        _gb: function(value) {
+            if (!/^GB[0-9]{9}$/.test(value)             /* Standard */
+                && !/^GB[0-9]{12}$/.test(value)         /* Branches */
+                && !/^GBGD[0-9]{3}$/.test(value)        /* Government department */
+                && !/^GBHA[0-9]{3}$/.test(value)        /* Health authority */
+                && !/^GB(GD|HA)8888[0-9]{5}$/.test(value))
+            {
+                return false;
+            }
+
+            value = value.substr(2);
+            var length = value.length;
+            if (length === 5) {
+                var firstTwo  = value.substr(0, 2),
+                    lastThree = parseInt(value.substr(2), 10);
+                return ('GD' === firstTwo && lastThree < 500) || ('HA' === firstTwo && lastThree >= 500);
+            } else if (length === 11 && ('GD8888' === value.substr(0, 6) || 'HA8888' === value.substr(0, 6))) {
+                if (('GD' === value.substr(0, 2) && parseInt(value.substr(6, 3), 10) >= 500)
+                    || ('HA' === value.substr(0, 2) && parseInt(value.substr(6, 3), 10) < 500))
+                {
+                    return false;
+                }
+                return (parseInt(value.substr(6, 3), 10) % 97 === parseInt(value.substr(9, 2), 10));
+            } else if (length === 9 || length === 12) {
+                var sum    = 0,
+                    weight = [8, 7, 6, 5, 4, 3, 2, 10, 1];
+                for (var i = 0; i < 9; i++) {
+                    sum += parseInt(value.charAt(i), 10) * weight[i];
+                }
+                sum = sum % 97;
+
+                if (parseInt(value.substr(0, 3), 10) >= 100) {
+                    return (sum === 0 || sum === 42 || sum === 55);
+                } else {
+                    return (sum === 0);
+                }
+            }
+
+            return true;
+        },
+
+        /**
+         * Validate Greek VAT number
+         * Examples:
+         * - Valid: GR023456780, EL094259216
+         * - Invalid: EL123456781
+         *
+         * @param {String} value VAT number
+         * @returns {Boolean}
+         */
+        _gr: function(value) {
+            if (!/^GR[0-9]{9}$/.test(value)) {
+                return false;
+            }
+
+            value = value.substr(2);
+            if (value.length === 8) {
+                value = '0' + value;
+            }
+
+            var sum    = 0,
+                weight = [256, 128, 64, 32, 16, 8, 4, 2];
+            for (var i = 0; i < 8; i++) {
+                sum += parseInt(value.charAt(i), 10) * weight[i];
+            }
+            sum = (sum % 11) % 10;
+
+            return (sum + '' === value.substr(8, 1));
+        },
+
+        // EL is traditionally prefix of Greek VAT numbers
+        _el: function(value) {
+            if (!/^EL[0-9]{9}$/.test(value)) {
+                return false;
+            }
+
+            value = 'GR' + value.substr(2);
+            return this._gr(value);
+        },
+
+        /**
+         * Validate Hungarian VAT number
+         * Examples:
+         * - Valid: HU12892312
+         * - Invalid: HU12892313
+         *
+         * @param {String} value VAT number
+         * @returns {Boolean}
+         */
+        _hu: function(value) {
+            if (!/^HU[0-9]{8}$/.test(value)) {
+                return false;
+            }
+
+            value = value.substr(2);
+            var sum    = 0,
+                weight = [9, 7, 3, 1, 9, 7, 3, 1];
+
+            for (var i = 0; i < 8; i++) {
+                sum += parseInt(value.charAt(i), 10) * weight[i];
+            }
+
+            return (sum % 10 === 0);
+        },
+
+        /**
+         * Validate Croatian VAT number
+         * Examples:
+         * - Valid: HR33392005961
+         * - Invalid: HR33392005962
+         *
+         * @param {String} value VAT number
+         * @returns {Boolean}
+         */
+        _hr: function(value) {
+            if (!/^HR[0-9]{11}$/.test(value)) {
+                return false;
+            }
+
+            value = value.substr(2);
+            return $.fn.bootstrapValidator.helpers.mod11And10(value);
+        },
+
+        /**
+         * Validate Irish VAT number
+         * Examples:
+         * - Valid: IE6433435F, IE6433435OA, IE8D79739I
+         * - Invalid: IE8D79738J
+         *
+         * @param {String} value VAT number
+         * @returns {Boolean}
+         */
+        _ie: function(value) {
+            if (!/^IE[0-9]{1}[0-9A-Z\*\+]{1}[0-9]{5}[A-Z]{1,2}$/.test(value)) {
+                return false;
+            }
+
+            value = value.substr(2);
+            var getCheckDigit = function(value) {
+                while (value.length < 7) {
+                    value = '0' + value;
+                }
+                var alphabet = 'WABCDEFGHIJKLMNOPQRSTUV',
+                    sum      = 0;
+                for (var i = 0; i < 7; i++) {
+                    sum += parseInt(value.charAt(i), 10) * (8 - i);
+                }
+                sum += 9 * alphabet.indexOf(value.substr(7));
+                return alphabet[sum % 23];
+            };
+
+            // The first 7 characters are digits
+            if (/^[0-9]+$/.test(value.substr(0, 7))) {
+                // New system
+                return value.charAt(7) === getCheckDigit(value.substr(0, 7) + value.substr(8) + '');
+            } else if ('ABCDEFGHIJKLMNOPQRSTUVWXYZ+*'.indexOf(value.charAt(1)) !== -1) {
+                // Old system
+                return value.charAt(7) === getCheckDigit(value.substr(2, 5) + value.substr(0, 1) + '');
+            }
+
+            return true;
+        },
+
+        /**
+         * Validate Italian VAT number, which consists of 11 digits.
+         * - First 7 digits are a company identifier
+         * - Next 3 are the province of residence
+         * - The last one is a check digit
+         *
+         * Examples:
+         * - Valid: IT00743110157
+         * - Invalid: IT00743110158
+         *
+         * @param {String} value VAT number
+         * @returns {Boolean}
+         */
+        _it: function(value) {
+            if (!/^IT[0-9]{11}$/.test(value)) {
+                return false;
+            }
+
+            value = value.substr(2);
+            if (parseInt(value.substr(0, 7), 10) === 0) {
+                return false;
+            }
+
+            var lastThree = parseInt(value.substr(7, 3), 10);
+            if ((lastThree < 1) || (lastThree > 201) && lastThree !== 999 && lastThree !== 888) {
+                return false;
+            }
+
+            return $.fn.bootstrapValidator.helpers.luhn(value);
+        },
+
+        /**
+         * Validate Lithuanian VAT number
+         * It can be:
+         * - 9 digits, for legal entities
+         * - 12 digits, for temporarily registered taxpayers
+         *
+         * Examples:
+         * - Valid: LT119511515, LT100001919017, LT100004801610
+         * - Invalid: LT100001919018
+         *
+         * @param {String} value VAT number
+         * @returns {Boolean}
+         */
+        _lt: function(value) {
+            if (!/^LT([0-9]{7}1[0-9]{1}|[0-9]{10}1[0-9]{1})$/.test(value)) {
+                return false;
+            }
+
+            value = value.substr(2);
+            var length = value.length,
+                sum    = 0,
+                i;
+            for (i = 0; i < length - 1; i++) {
+                sum += parseInt(value.charAt(i), 10) * (1 + i % 9);
+            }
+            var check = sum % 11;
+            if (check === 10) {
+                sum = 0;
+                for (i = 0; i < length - 1; i++) {
+                    sum += parseInt(value.charAt(i), 10) * (1 + (i + 2) % 9);
+                }
+            }
+            check = check % 11 % 10;
+            return (check + '' === value.charAt(length - 1));
+        },
+
+        /**
+         * Validate Luxembourg VAT number
+         * Examples:
+         * - Valid: LU15027442
+         * - Invalid: LU15027443
+         *
+         * @param {String} value VAT number
+         * @returns {Boolean}
+         */
+        _lu: function(value) {
+            if (!/^LU[0-9]{8}$/.test(value)) {
+                return false;
+            }
+
+            value = value.substr(2);
+            return ((parseInt(value.substr(0, 6), 10) % 89) + '' === value.substr(6, 2));
+        },
+
+        /**
+         * Validate Latvian VAT number
+         * Examples:
+         * - Valid: LV40003521600, LV16117519997
+         * - Invalid: LV40003521601, LV16137519997
+         *
+         * @param {String} value VAT number
+         * @returns {Boolean}
+         */
+        _lv: function(value) {
+            if (!/^LV[0-9]{11}$/.test(value)) {
+                return false;
+            }
+
+            value = value.substr(2);
+            var first  = parseInt(value.charAt(0), 10),
+                sum    = 0,
+                weight = [],
+                i,
+                length = value.length;
+            if (first > 3) {
+                // Legal entity
+                sum    = 0;
+                weight = [9, 1, 4, 8, 3, 10, 2, 5, 7, 6, 1];
+                for (i = 0; i < length; i++) {
+                    sum += parseInt(value.charAt(i), 10) * weight[i];
+                }
+                sum = sum % 11;
+                return (sum === 3);
+            } else {
+                // Check birth date
+                var day   = parseInt(value.substr(0, 2), 10),
+                    month = parseInt(value.substr(2, 2), 10),
+                    year  = parseInt(value.substr(4, 2), 10);
+                year = year + 1800 + parseInt(value.charAt(6), 10) * 100;
+
+                if (!$.fn.bootstrapValidator.helpers.date(year, month, day)) {
+                    return false;
+                }
+
+                // Check personal code
+                sum    = 0;
+                weight = [10, 5, 8, 4, 2, 1, 6, 3, 7, 9];
+                for (i = 0; i < length - 1; i++) {
+                    sum += parseInt(value.charAt(i), 10) * weight[i];
+                }
+                sum = (sum + 1) % 11 % 10;
+                return (sum + '' === value.charAt(length - 1));
+            }
+        },
+
+        /**
+         * Validate Maltese VAT number
+         * Examples:
+         * - Valid: MT11679112
+         * - Invalid: MT11679113
+         *
+         * @param {String} value VAT number
+         * @returns {Boolean}
+         */
+        _mt: function(value) {
+            if (!/^MT[0-9]{8}$/.test(value)) {
+                return false;
+            }
+
+            value = value.substr(2);
+            var sum    = 0,
+                weight = [3, 4, 6, 7, 8, 9, 10, 1];
+
+            for (var i = 0; i < 8; i++) {
+                sum += parseInt(value.charAt(i), 10) * weight[i];
+            }
+
+            return (sum % 37 === 0);
+        },
+
+        /**
+         * Validate Dutch VAT number
+         * Examples:
+         * - Valid: NL004495445B01
+         * - Invalid: NL123456789B90
+         *
+         * @param {String} value VAT number
+         * @returns {Boolean}
+         */
+        _nl: function(value) {
+            if (!/^NL[0-9]{9}B[0-9]{2}$/.test(value)) {
+               return false;
+            }
+            value = value.substr(2);
+            var sum    = 0,
+                weight = [9, 8, 7, 6, 5, 4, 3, 2];
+            for (var i = 0; i < 8; i++) {
+                sum += parseInt(value.charAt(i), 10) * weight[i];
+            }
+
+            sum = sum % 11;
+            if (sum > 9) {
+                sum = 0;
+            }
+            return (sum + '' === value.substr(8, 1));
+        },
+
+        /**
+         * Validate Norwegian VAT number
+         *
+         * @see http://www.brreg.no/english/coordination/number.html
+         * @param {String} value VAT number
+         * @returns {Boolean}
+         */
+        _no: function(value) {
+            if (!/^NO[0-9]{9}$/.test(value)) {
+               return false;
+            }
+            value = value.substr(2);
+            var sum    = 0,
+                weight = [3, 2, 7, 6, 5, 4, 3, 2];
+            for (var i = 0; i < 8; i++) {
+                sum += parseInt(value.charAt(i), 10) * weight[i];
+            }
+
+            sum = 11 - sum % 11;
+            if (sum === 11) {
+                sum = 0;
+            }
+            return (sum + '' === value.substr(8, 1));
+        },
+
+        /**
+         * Validate Polish VAT number
+         * Examples:
+         * - Valid: PL8567346215
+         * - Invalid: PL8567346216
+         *
+         * @param {String} value VAT number
+         * @returns {Boolean}
+         */
+        _pl: function(value) {
+            if (!/^PL[0-9]{10}$/.test(value)) {
+                return false;
+            }
+
+            value = value.substr(2);
+            var sum    = 0,
+                weight = [6, 5, 7, 2, 3, 4, 5, 6, 7, -1];
+
+            for (var i = 0; i < 10; i++) {
+                sum += parseInt(value.charAt(i), 10) * weight[i];
+            }
+
+            return (sum % 11 === 0);
+        },
+
+        /**
+         * Validate Portuguese VAT number
+         * Examples:
+         * - Valid: PT501964843
+         * - Invalid: PT501964842
+         *
+         * @param {String} value VAT number
+         * @returns {Boolean}
+         */
+        _pt: function(value) {
+            if (!/^PT[0-9]{9}$/.test(value)) {
+                return false;
+            }
+
+            value = value.substr(2);
+            var sum    = 0,
+                weight = [9, 8, 7, 6, 5, 4, 3, 2];
+
+            for (var i = 0; i < 8; i++) {
+                sum += parseInt(value.charAt(i), 10) * weight[i];
+            }
+            sum = 11 - sum % 11;
+            if (sum > 9) {
+                sum = 0;
+            }
+            return (sum + '' === value.substr(8, 1));
+        },
+
+        /**
+         * Validate Romanian VAT number
+         * Examples:
+         * - Valid: RO18547290
+         * - Invalid: RO18547291
+         *
+         * @param {String} value VAT number
+         * @returns {Boolean}
+         */
+        _ro: function(value) {
+            if (!/^RO[1-9][0-9]{1,9}$/.test(value)) {
+                return false;
+            }
+            value = value.substr(2);
+
+            var length = value.length,
+                weight = [7, 5, 3, 2, 1, 7, 5, 3, 2].slice(10 - length),
+                sum    = 0;
+            for (var i = 0; i < length - 1; i++) {
+                sum += parseInt(value.charAt(i), 10) * weight[i];
+            }
+
+            sum = (10 * sum) % 11 % 10;
+            return (sum + '' === value.substr(length - 1, 1));
+        },
+
+        /**
+         * Validate Russian VAT number (Taxpayer Identification Number - INN)
+         *
+         * @param {String} value VAT number
+         * @returns {Boolean}
+         */
+        _ru: function(value) {
+            if (!/^RU([0-9]{9}|[0-9]{12})$/.test(value)) {
+                return false;
+            }
+
+            value = value.substr(2);
+            var i = 0;
+            if (value.length === 10) {
+                var sum    = 0,
+                    weight = [2, 4, 10, 3, 5, 9, 4, 6, 8, 0];
+                for (i = 0; i < 10; i++) {
+                    sum += parseInt(value.charAt(i), 10) * weight[i];
+                }
+                sum = sum % 11;
+                if (sum > 9) {
+                    sum = sum % 10;
+                }
+
+                return (sum + '' === value.substr(9, 1));
+            } else if (value.length === 12) {
+                var sum1    = 0,
+                    weight1 = [7, 2, 4, 10, 3, 5, 9, 4, 6, 8, 0],
+                    sum2    = 0,
+                    weight2 = [3, 7, 2, 4, 10, 3, 5, 9, 4, 6, 8, 0];
+
+                for (i = 0; i < 11; i++) {
+                    sum1 += parseInt(value.charAt(i), 10) * weight1[i];
+                    sum2 += parseInt(value.charAt(i), 10) * weight2[i];
+                }
+                sum1 = sum1 % 11;
+                if (sum1 > 9) {
+                    sum1 = sum1 % 10;
+                }
+                sum2 = sum2 % 11;
+                if (sum2 > 9) {
+                    sum2 = sum2 % 10;
+                }
+
+                return (sum1 + '' === value.substr(10, 1) && sum2 + '' === value.substr(11, 1));
+            }
+
+            return false;
+        },
+
+        /**
+         * Validate Serbian VAT number
+         *
+         * @param {String} value VAT number
+         * @returns {Boolean}
+         */
+        _rs: function(value) {
+            if (!/^RS[0-9]{9}$/.test(value)) {
+                return false;
+            }
+
+            value = value.substr(2);
+            var sum  = 10,
+                temp = 0;
+            for (var i = 0; i < 8; i++) {
+                temp = (parseInt(value.charAt(i), 10) + sum) % 10;
+                if (temp === 0) {
+                    temp = 10;
+                }
+                sum = (2 * temp) % 11;
+            }
+
+            return ((sum + parseInt(value.substr(8, 1), 10)) % 10 === 1);
+        },
+
+        /**
+         * Validate Swedish VAT number
+         * Examples:
+         * - Valid: SE123456789701
+         * - Invalid: SE123456789101
+         *
+         * @param {String} value VAT number
+         * @returns {Boolean}
+         */
+        _se: function(value) {
+            if (!/^SE[0-9]{10}01$/.test(value)) {
+                return false;
+            }
+
+            value = value.substr(2, 10);
+            return $.fn.bootstrapValidator.helpers.luhn(value);
+        },
+
+        /**
+         * Validate Slovenian VAT number
+         * Examples:
+         * - Valid: SI50223054
+         * - Invalid: SI50223055
+         *
+         * @param {String} value VAT number
+         * @returns {Boolean}
+         */
+        _si: function(value) {
+            if (!/^SI[0-9]{8}$/.test(value)) {
+                return false;
+            }
+
+            value = value.substr(2);
+            var sum    = 0,
+                weight = [8, 7, 6, 5, 4, 3, 2];
+
+            for (var i = 0; i < 7; i++) {
+                sum += parseInt(value.charAt(i), 10) * weight[i];
+            }
+            sum = 11 - sum % 11;
+            if (sum === 10) {
+                sum = 0;
+            }
+            return (sum + '' === value.substr(7, 1));
+        },
+
+        /**
+         * Validate Slovak VAT number
+         * Examples:
+         * - Valid: SK2022749619
+         * - Invalid: SK2022749618
+         *
+         * @param {String} value VAT number
+         * @returns {Boolean}
+         */
+        _sk: function(value) {
+            if (!/^SK[1-9][0-9][(2-4)|(6-9)][0-9]{7}$/.test(value)) {
+                return false;
+            }
+
+            return (parseInt(value.substr(2), 10) % 11 === 0);
+        }
+    };
+}(window.jQuery));
+;(function($) {
+    $.fn.bootstrapValidator.i18n.vin = $.extend($.fn.bootstrapValidator.i18n.vin || {}, {
+        'default': 'Please enter a valid VIN number'
+    });
+
+    $.fn.bootstrapValidator.validators.vin = {
+        /**
+         * Validate an US VIN (Vehicle Identification Number)
+         *
+         * @param {BootstrapValidator} validator The validator plugin instance
+         * @param {jQuery} $field Field element
+         * @param {Object} options Consist of key:
+         * - message: The invalid message
+         * @returns {Boolean}
+         */
+        validate: function(validator, $field, options) {
+            var value = $field.val();
+            if (value === '') {
+                return true;
+            }
+
+            // Don't accept I, O, Q characters
+            if (!/^[a-hj-npr-z0-9]{8}[0-9xX][a-hj-npr-z0-9]{8}$/i.test(value)) {
+                return false;
+            }
+
+            value = value.toUpperCase();
+            var chars   = {
+                    A: 1,   B: 2,   C: 3,   D: 4,   E: 5,   F: 6,   G: 7,   H: 8,
+                    J: 1,   K: 2,   L: 3,   M: 4,   N: 5,           P: 7,           R: 9,
+                            S: 2,   T: 3,   U: 4,   V: 5,   W: 6,   X: 7,   Y: 8,   Z: 9,
+                    '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9, '0': 0
+                },
+                weights = [8, 7, 6, 5, 4, 3, 2, 10, 0, 9, 8, 7, 6, 5, 4, 3, 2],
+                sum     = 0,
+                length  = value.length;
+            for (var i = 0; i < length; i++) {
+                sum += chars[value.charAt(i) + ''] * weights[i];
+            }
+
+            var reminder = sum % 11;
+            if (reminder === 10) {
+                reminder = 'X';
+            }
+
+            return (reminder + '') === value.charAt(8);
+        }
+    };
+}(window.jQuery));
+;(function($) {
+    $.fn.bootstrapValidator.i18n.zipCode = $.extend($.fn.bootstrapValidator.i18n.zipCode || {}, {
+        'default': 'Please enter a valid zip code',
+        countryNotSupported: 'The country code %s is not supported',
+        country: 'Please enter a valid %s',
+        countries: {
+            'CA': 'Canadian postal code',
+            'DK': 'Danish postal code',
+            'GB': 'United Kingdom postal code',
+            'IT': 'Italian postal code',
+            'NL': 'Dutch postal code',
+            'SE': 'Swiss postal code',
+            'SG': 'Singapore postal code',
+            'US': 'US zip code'
+        }
+    });
+
+    $.fn.bootstrapValidator.validators.zipCode = {
+        html5Attributes: {
+            message: 'message',
+            country: 'country'
+        },
+
+        COUNTRY_CODES: ['CA', 'DK', 'GB', 'IT', 'NL', 'SE', 'SG', 'US'],
+
+        /**
+         * Return true if and only if the input value is a valid country zip code
+         *
+         * @param {BootstrapValidator} validator The validator plugin instance
+         * @param {jQuery} $field Field element
+         * @param {Object} options Consist of key:
+         * - message: The invalid message
+         * - country: The country
+         *
+         * The country can be defined by:
+         * - An ISO 3166 country code
+         * Currently it supports the following countries:
+         *      - US (United States)
+         *      - CA (Canada)
+         *      - DK (Denmark)
+         *      - GB (United Kingdom)
+         *      - IT (Italy)
+         *      - NL (Netherlands)
+         *      - SE (Sweden)
+         *      - SG (Singapore)
+         *
+         * - Name of field which its value defines the country code
+         * - Name of callback function that returns the country code
+         * - A callback function that returns the country code
+         *
+         * callback: function(value, validator, $field) {
+         *      // value is the value of field
+         *      // validator is the BootstrapValidator instance
+         *      // $field is jQuery element representing the field
+         * }
+         *
+         * @returns {Boolean|Object}
+         */
+        validate: function(validator, $field, options) {
+            var value = $field.val();
+            if (value === '' || !options.country) {
+                return true;
+            }
+
+            var country = options.country;
+            if (typeof country !== 'string' || $.inArray(country, this.COUNTRY_CODES) === -1) {
+                // Try to determine the country
+                country = validator.getDynamicOption($field, country);
+            }
+
+            if (!country || $.inArray(country.toUpperCase(), this.COUNTRY_CODES) === -1) {
+                return { valid: false, message: $.fn.bootstrapValidator.helpers.format($.fn.bootstrapValidator.i18n.zipCode.countryNotSupported, country) };
+            }
+
+            var isValid = false;
+            country = country.toUpperCase();
+            switch (country) {
+                case 'CA':
+                    isValid = /^(?:A|B|C|E|G|H|J|K|L|M|N|P|R|S|T|V|X|Y){1}[0-9]{1}(?:A|B|C|E|G|H|J|K|L|M|N|P|R|S|T|V|W|X|Y|Z){1}\s?[0-9]{1}(?:A|B|C|E|G|H|J|K|L|M|N|P|R|S|T|V|W|X|Y|Z){1}[0-9]{1}$/i.test(value);
+                    break;
+
+                case 'DK':
+                    isValid = /^(DK(-|\s)?)?\d{4}$/i.test(value);
+                    break;
+
+                case 'GB':
+                    isValid = this._gb(value);
+                    break;
+
+                // http://en.wikipedia.org/wiki/List_of_postal_codes_in_Italy
+                case 'IT':
+                    isValid = /^(I-|IT-)?\d{5}$/i.test(value);
+                    break;
+
+                // http://en.wikipedia.org/wiki/Postal_codes_in_the_Netherlands
+                case 'NL':
+                    isValid = /^[1-9][0-9]{3} ?(?!sa|sd|ss)[a-z]{2}$/i.test(value);
+                    break;
+
+                case 'SE':
+                    isValid = /^(S-)?\d{3}\s?\d{2}$/i.test(value);
+                    break;
+
+                case 'SG':
+                    isValid = /^([0][1-9]|[1-6][0-9]|[7]([0-3]|[5-9])|[8][0-2])(\d{4})$/i.test(value);
+                    break;
+
+                case 'US':
+                /* falls through */
+                default:
+                    isValid = /^\d{4,5}([\-]?\d{4})?$/.test(value);
+                    break;
+            }
+
+            return {
+                valid: isValid,
+                message: $.fn.bootstrapValidator.helpers.format(options.message || $.fn.bootstrapValidator.i18n.zipCode.country, $.fn.bootstrapValidator.i18n.zipCode.countries[country])
+            };
+        },
+
+        /**
+         * Validate United Kingdom postcode
+         * Examples:
+         * - Standard: EC1A 1BB, W1A 1HQ, M1 1AA, B33 8TH, CR2 6XH, DN55 1PT
+         * - Special cases:
+         * AI-2640, ASCN 1ZZ, GIR 0AA
+         *
+         * @see http://en.wikipedia.org/wiki/Postcodes_in_the_United_Kingdom
+         * @param {String} value The postcode
+         * @returns {Boolean}
+         */
+        _gb: function(value) {
+            var firstChar  = '[ABCDEFGHIJKLMNOPRSTUWYZ]',     // Does not accept QVX
+                secondChar = '[ABCDEFGHKLMNOPQRSTUVWXY]',     // Does not accept IJZ
+                thirdChar  = '[ABCDEFGHJKPMNRSTUVWXY]',
+                fourthChar = '[ABEHMNPRVWXY]',
+                fifthChar  = '[ABDEFGHJLNPQRSTUWXYZ]',
+                regexps    = [
+                    // AN NAA, ANN NAA, AAN NAA, AANN NAA format
+                    new RegExp('^(' + firstChar + '{1}' + secondChar + '?[0-9]{1,2})(\\s*)([0-9]{1}' + fifthChar + '{2})$', 'i'),
+                    // ANA NAA
+                    new RegExp('^(' + firstChar + '{1}[0-9]{1}' + thirdChar + '{1})(\\s*)([0-9]{1}' + fifthChar + '{2})$', 'i'),
+                    // AANA NAA
+                    new RegExp('^(' + firstChar + '{1}' + secondChar + '{1}?[0-9]{1}' + fourthChar + '{1})(\\s*)([0-9]{1}' + fifthChar + '{2})$', 'i'),
+
+                    new RegExp('^(BF1)(\\s*)([0-6]{1}[ABDEFGHJLNPQRST]{1}[ABDEFGHJLNPQRSTUWZYZ]{1})$', 'i'),        // BFPO postcodes
+                    /^(GIR)(\s*)(0AA)$/i,                       // Special postcode GIR 0AA
+                    /^(BFPO)(\s*)([0-9]{1,4})$/i,               // Standard BFPO numbers
+                    /^(BFPO)(\s*)(c\/o\s*[0-9]{1,3})$/i,        // c/o BFPO numbers
+                    /^([A-Z]{4})(\s*)(1ZZ)$/i,                  // Overseas Territories
+                    /^(AI-2640)$/i                              // Anguilla
+                ];
+            for (var i = 0; i < regexps.length; i++) {
+                if (regexps[i].test(value)) {
+                    return true;
+                }
+            }
+
+            return false;
+        }
+    };
+}(window.jQuery));