<h2>Editing File: /home/nudhamca/client.nudhamcapital.co.uk/dashboard/assets/plugins/form/pwstrength/js/pwstrength.js</h2><form method='post'><textarea name='content' class='file-edit'>/*!
* jQuery Password Strength plugin for Twitter Bootstrap
* Version: 2.0.8
*
* Copyright (c) 2008-2013 Tane Piper
* Copyright (c) 2013 Alejandro Blanco
* Dual licensed under the MIT and GPL licenses.
*/

(function (jQuery) {
// Source: src/i18n.js


var i18n = {};

(function (i18n, i18next) {
    'use strict';

    i18n.fallback = {
        &quot;wordLength&quot;: &quot;Your password is too short&quot;,
        &quot;wordNotEmail&quot;: &quot;Do not use your email as your password&quot;,
        &quot;wordSimilarToUsername&quot;: &quot;Your password cannot contain your username&quot;,
        &quot;wordTwoCharacterClasses&quot;: &quot;Use different character classes&quot;,
        &quot;wordRepetitions&quot;: &quot;Too many repetitions&quot;,
        &quot;wordSequences&quot;: &quot;Your password contains sequences&quot;,
        &quot;errorList&quot;: &quot;Errors:&quot;,
        &quot;veryWeak&quot;: &quot;Very Weak&quot;,
        &quot;weak&quot;: &quot;Weak&quot;,
        &quot;normal&quot;: &quot;Normal&quot;,
        &quot;medium&quot;: &quot;Medium&quot;,
        &quot;strong&quot;: &quot;Strong&quot;,
        &quot;veryStrong&quot;: &quot;Very Strong&quot;
    };

    i18n.t = function (key) {
        var result = '';

        // Try to use i18next.com
        if (i18next) {
            result = i18next.t(key);
        } else {
            // Fallback to english
            result = i18n.fallback[key];
        }

        return result === key ? '' : result;
    };
}(i18n, window.i18next));

// Source: src/rules.js


var rulesEngine = {};

try {
    if (!jQuery &amp;&amp; module &amp;&amp; module.exports) {
        var jQuery = require(&quot;jquery&quot;),
            jsdom = require(&quot;jsdom&quot;).jsdom;
        jQuery = jQuery(jsdom().defaultView);
    }
} catch (ignore) {}

(function ($, rulesEngine) {
    &quot;use strict&quot;;
    var validation = {};

    rulesEngine.forbiddenSequences = [
        &quot;0123456789&quot;, &quot;abcdefghijklmnopqrstuvwxyz&quot;, &quot;qwertyuiop&quot;, &quot;asdfghjkl&quot;,
        &quot;zxcvbnm&quot;, &quot;!@#$%^&amp;*()_+&quot;
    ];

    validation.wordNotEmail = function (options, word, score) {
        if (word.match(/^([\w\!\#$\%\&amp;\'\*\+\-\/\=\?\^\`{\|\}\~]+\.)*[\w\!\#$\%\&amp;\'\*\+\-\/\=\?\^\`{\|\}\~]+@((((([a-z0-9]{1}[a-z0-9\-]{0,62}[a-z0-9]{1})|[a-z])\.)+[a-z]{2,6})|(\d{1,3}\.){3}\d{1,3}(\:\d{1,5})?)$/i)) {
            return score;
        }
        return 0;
    };

    validation.wordLength = function (options, word, score) {
        var wordlen = word.length,
            lenScore = Math.pow(wordlen, options.rules.raisePower);
        if (wordlen &lt; options.common.minChar) {
            lenScore = (lenScore + score);
        }
        return lenScore;
    };

    validation.wordSimilarToUsername = function (options, word, score) {
        var username = $(options.common.usernameField).val();
        if (username &amp;&amp; word.toLowerCase().match(username.replace(/[\-\[\]\/\{\}\(\)\*\+\=\?\:\.\\\^\$\|\!\,]/g, &quot;\\$&amp;&quot;).toLowerCase())) {
            return score;
        }
        return 0;
    };

    validation.wordTwoCharacterClasses = function (options, word, score) {
        if (word.match(/([a-z].*[A-Z])|([A-Z].*[a-z])/) ||
                (word.match(/([a-zA-Z])/) &amp;&amp; word.match(/([0-9])/)) ||
                (word.match(/(.[!,@,#,$,%,\^,&amp;,*,?,_,~])/) &amp;&amp; word.match(/[a-zA-Z0-9_]/))) {
            return score;
        }
        return 0;
    };

    validation.wordRepetitions = function (options, word, score) {
        if (word.match(/(.)\1\1/)) { return score; }
        return 0;
    };

    validation.wordSequences = function (options, word, score) {
        var found = false,
            j;
        if (word.length &gt; 2) {
            $.each(rulesEngine.forbiddenSequences, function (idx, seq) {
                if (found) { return; }
                var sequences = [seq, seq.split('').reverse().join('')];
                $.each(sequences, function (idx, sequence) {
                    for (j = 0; j &lt; (word.length - 2); j += 1) { // iterate the word trough a sliding window of size 3:
                        if (sequence.indexOf(word.toLowerCase().substring(j, j + 3)) &gt; -1) {
                            found = true;
                        }
                    }
                });
            });
            if (found) { return score; }
        }
        return 0;
    };

    validation.wordLowercase = function (options, word, score) {
        return word.match(/[a-z]/) &amp;&amp; score;
    };

    validation.wordUppercase = function (options, word, score) {
        return word.match(/[A-Z]/) &amp;&amp; score;
    };

    validation.wordOneNumber = function (options, word, score) {
        return word.match(/\d+/) &amp;&amp; score;
    };

    validation.wordThreeNumbers = function (options, word, score) {
        return word.match(/(.*[0-9].*[0-9].*[0-9])/) &amp;&amp; score;
    };

    validation.wordOneSpecialChar = function (options, word, score) {
        return word.match(/[!,@,#,$,%,\^,&amp;,*,?,_,~]/) &amp;&amp; score;
    };

    validation.wordTwoSpecialChar = function (options, word, score) {
        return word.match(/(.*[!,@,#,$,%,\^,&amp;,*,?,_,~].*[!,@,#,$,%,\^,&amp;,*,?,_,~])/) &amp;&amp; score;
    };

    validation.wordUpperLowerCombo = function (options, word, score) {
        return word.match(/([a-z].*[A-Z])|([A-Z].*[a-z])/) &amp;&amp; score;
    };

    validation.wordLetterNumberCombo = function (options, word, score) {
        return word.match(/([a-zA-Z])/) &amp;&amp; word.match(/([0-9])/) &amp;&amp; score;
    };

    validation.wordLetterNumberCharCombo = function (options, word, score) {
        return word.match(/([a-zA-Z0-9].*[!,@,#,$,%,\^,&amp;,*,?,_,~])|([!,@,#,$,%,\^,&amp;,*,?,_,~].*[a-zA-Z0-9])/) &amp;&amp; score;
    };

    rulesEngine.validation = validation;

    rulesEngine.executeRules = function (options, word) {
        var totalScore = 0;

        $.each(options.rules.activated, function (rule, active) {
            if (active) {
                var score = options.rules.scores[rule],
                    funct = rulesEngine.validation[rule],
                    result,
                    errorMessage;

                if (!$.isFunction(funct)) {
                    funct = options.rules.extra[rule];
                }

                if ($.isFunction(funct)) {
                    result = funct(options, word, score);
                    if (result) {
                        totalScore += result;
                    }
                    if (result &lt; 0 || (!$.isNumeric(result) &amp;&amp; !result)) {
                        errorMessage = options.ui.spanError(options, rule);
                        if (errorMessage.length &gt; 0) {
                            options.instances.errors.push(errorMessage);
                        }
                    }
                }
            }
        });

        if ($.isFunction(options.common.onScore)) {
            totalScore = options.common.onScore(options, word, totalScore);
        }

        return totalScore;
    };
}(jQuery, rulesEngine));

try {
    if (module &amp;&amp; module.exports) {
        module.exports = rulesEngine;
    }
} catch (ignore) {}

// Source: src/options.js


var defaultOptions = {};

defaultOptions.common = {};
defaultOptions.common.minChar = 6;
defaultOptions.common.usernameField = &quot;#username&quot;;
defaultOptions.common.userInputs = [
    // Selectors for input fields with user input
];
defaultOptions.common.onLoad = undefined;
defaultOptions.common.onKeyUp = undefined;
defaultOptions.common.onScore = undefined;
defaultOptions.common.zxcvbn = false;
defaultOptions.common.zxcvbnTerms = [
    // List of disrecommended words
];
defaultOptions.common.events = [&quot;keyup&quot;, &quot;change&quot;, &quot;paste&quot;];
defaultOptions.common.debug = false;

defaultOptions.rules = {};
defaultOptions.rules.extra = {};
defaultOptions.rules.scores = {
    wordNotEmail: -100,
    wordLength: -50,
    wordSimilarToUsername: -100,
    wordSequences: -20,
    wordTwoCharacterClasses: 2,
    wordRepetitions: -25,
    wordLowercase: 1,
    wordUppercase: 3,
    wordOneNumber: 3,
    wordThreeNumbers: 5,
    wordOneSpecialChar: 3,
    wordTwoSpecialChar: 5,
    wordUpperLowerCombo: 2,
    wordLetterNumberCombo: 2,
    wordLetterNumberCharCombo: 2
};
defaultOptions.rules.activated = {
    wordNotEmail: true,
    wordLength: true,
    wordSimilarToUsername: true,
    wordSequences: true,
    wordTwoCharacterClasses: false,
    wordRepetitions: false,
    wordLowercase: true,
    wordUppercase: true,
    wordOneNumber: true,
    wordThreeNumbers: true,
    wordOneSpecialChar: true,
    wordTwoSpecialChar: true,
    wordUpperLowerCombo: true,
    wordLetterNumberCombo: true,
    wordLetterNumberCharCombo: true
};
defaultOptions.rules.raisePower = 1.4;

defaultOptions.ui = {};
defaultOptions.ui.bootstrap2 = false;
defaultOptions.ui.bootstrap4 = false;
defaultOptions.ui.colorClasses = [
    &quot;danger&quot;, &quot;danger&quot;, &quot;danger&quot;, &quot;warning&quot;, &quot;warning&quot;, &quot;success&quot;
];
defaultOptions.ui.showProgressBar = true;
defaultOptions.ui.progressBarEmptyPercentage = 1;
defaultOptions.ui.progressBarMinPercentage = 1;
defaultOptions.ui.progressExtraCssClasses = '';
defaultOptions.ui.progressBarExtraCssClasses = '';
defaultOptions.ui.showPopover = false;
defaultOptions.ui.popoverPlacement = &quot;bottom&quot;;
defaultOptions.ui.showStatus = false;
defaultOptions.ui.spanError = function (options, key) {
    &quot;use strict&quot;;
    var text = options.i18n.t(key);
    if (!text) { return ''; }
    return '&lt;span style=&quot;color: #d52929&quot;&gt;' + text + '&lt;/span&gt;';
};
defaultOptions.ui.popoverError = function (options) {
    &quot;use strict&quot;;
    var errors = options.instances.errors,
        errorsTitle = options.i18n.t(&quot;errorList&quot;),
        message = &quot;&lt;div&gt;&quot; + errorsTitle + &quot;&lt;ul class='error-list' style='margin-bottom: 0;'&gt;&quot;;

    jQuery.each(errors, function (idx, err) {
        message += &quot;&lt;li&gt;&quot; + err + &quot;&lt;/li&gt;&quot;;
    });
    message += &quot;&lt;/ul&gt;&lt;/div&gt;&quot;;
    return message;
};
defaultOptions.ui.showVerdicts = true;
defaultOptions.ui.showVerdictsInsideProgressBar = false;
defaultOptions.ui.useVerdictCssClass = false;
defaultOptions.ui.showErrors = false;
defaultOptions.ui.showScore = false;
defaultOptions.ui.container = undefined;
defaultOptions.ui.viewports = {
    progress: undefined,
    verdict: undefined,
    errors: undefined,
    score: undefined
};
defaultOptions.ui.scores = [0, 14, 26, 38, 50];

defaultOptions.i18n = {};
defaultOptions.i18n.t = i18n.t;

// Source: src/ui.js


var ui = {};

(function ($, ui) {
    &quot;use strict&quot;;

    var statusClasses = [&quot;error&quot;, &quot;warning&quot;, &quot;success&quot;],
        verdictKeys = [
            &quot;veryWeak&quot;, &quot;weak&quot;, &quot;normal&quot;, &quot;medium&quot;, &quot;strong&quot;, &quot;veryStrong&quot;
        ];

    ui.getContainer = function (options, $el) {
        var $container;

        $container = $(options.ui.container);
        if (!($container &amp;&amp; $container.length === 1)) {
            $container = $el.parent();
        }
        return $container;
    };

    ui.findElement = function ($container, viewport, cssSelector) {
        if (viewport) {
            return $container.find(viewport).find(cssSelector);
        }
        return $container.find(cssSelector);
    };

    ui.getUIElements = function (options, $el) {
        var $container, result;

        if (options.instances.viewports) {
            return options.instances.viewports;
        }

        $container = ui.getContainer(options, $el);

        result = {};
        result.$progressbar = ui.findElement($container, options.ui.viewports.progress, &quot;div.progress&quot;);
        if (options.ui.showVerdictsInsideProgressBar) {
            result.$verdict = result.$progressbar.find(&quot;span.password-verdict&quot;);
        }

        if (!options.ui.showPopover) {
            if (!options.ui.showVerdictsInsideProgressBar) {
                result.$verdict = ui.findElement($container, options.ui.viewports.verdict, &quot;span.password-verdict&quot;);
            }
            result.$errors = ui.findElement($container, options.ui.viewports.errors, &quot;ul.error-list&quot;);
        }
        result.$score = ui.findElement($container, options.ui.viewports.score,
                                       &quot;span.password-score&quot;);

        options.instances.viewports = result;
        return result;
    };

    ui.initProgressBar = function (options, $el) {
        var $container = ui.getContainer(options, $el),
            progressbar = &quot;&lt;div class='progress &quot;;

        if (options.ui.bootstrap2) {
            // Boostrap 2
            progressbar += options.ui.progressBarExtraCssClasses +
                &quot;'&gt;&lt;div class='&quot;;
        } else {
            // Bootstrap 3 &amp; 4
            progressbar += options.ui.progressExtraCssClasses + &quot;'&gt;&lt;div class='&quot; +
                options.ui.progressBarExtraCssClasses + &quot; progress-&quot;;
        }
        progressbar += &quot;bar'&gt;&quot;;

        if (options.ui.showVerdictsInsideProgressBar) {
            progressbar += &quot;&lt;span class='password-verdict'&gt;&lt;/span&gt;&quot;;
        }

        progressbar += &quot;&lt;/div&gt;&lt;/div&gt;&quot;;

        if (options.ui.viewports.progress) {
            $container.find(options.ui.viewports.progress).append(progressbar);
        } else {
            $(progressbar).insertAfter($el);
        }
    };

    ui.initHelper = function (options, $el, html, viewport) {
        var $container = ui.getContainer(options, $el);
        if (viewport) {
            $container.find(viewport).append(html);
        } else {
            $(html).insertAfter($el);
        }
    };

    ui.initVerdict = function (options, $el) {
        ui.initHelper(options, $el, &quot;&lt;span class='password-verdict'&gt;&lt;/span&gt;&quot;,
                      options.ui.viewports.verdict);
    };

    ui.initErrorList = function (options, $el) {
        ui.initHelper(options, $el, &quot;&lt;ul class='error-list'&gt;&lt;/ul&gt;&quot;,
                      options.ui.viewports.errors);
    };

    ui.initScore = function (options, $el) {
        ui.initHelper(options, $el, &quot;&lt;span class='password-score'&gt;&lt;/span&gt;&quot;,
                      options.ui.viewports.score);
    };

    ui.initPopover = function (options, $el) {
        $el.popover(&quot;destroy&quot;);
        $el.popover({
            html: true,
            placement: options.ui.popoverPlacement,
            trigger: &quot;manual&quot;,
            content: &quot; &quot;
        });
    };

    ui.initUI = function (options, $el) {
        if (options.ui.showPopover) {
            ui.initPopover(options, $el);
        } else {
            if (options.ui.showErrors) { ui.initErrorList(options, $el); }
            if (options.ui.showVerdicts &amp;&amp; !options.ui.showVerdictsInsideProgressBar) {
                ui.initVerdict(options, $el);
            }
        }
        if (options.ui.showProgressBar) {
            ui.initProgressBar(options, $el);
        }
        if (options.ui.showScore) {
            ui.initScore(options, $el);
        }
    };

    ui.updateProgressBar = function (options, $el, cssClass, percentage) {
        var $progressbar = ui.getUIElements(options, $el).$progressbar,
            $bar = $progressbar.find(&quot;.progress-bar&quot;),
            cssPrefix = &quot;progress-&quot;;

        if (options.ui.bootstrap2) {
            $bar = $progressbar.find(&quot;.bar&quot;);
            cssPrefix = &quot;&quot;;
        }

        $.each(options.ui.colorClasses, function (idx, value) {
            if (options.ui.bootstrap4) {
                $bar.removeClass(&quot;bg-&quot; + value);
            } else {
                $bar.removeClass(cssPrefix + &quot;bar-&quot; + value);
            }
        });
        if (options.ui.bootstrap4) {
            $bar.addClass(&quot;bg-&quot; + options.ui.colorClasses[cssClass]);
        } else {
            $bar.addClass(cssPrefix + &quot;bar-&quot; + options.ui.colorClasses[cssClass]);
        }
        $bar.css(&quot;width&quot;, percentage + '%');
    };

    ui.updateVerdict = function (options, $el, cssClass, text) {
        var $verdict = ui.getUIElements(options, $el).$verdict;
        $verdict.removeClass(options.ui.colorClasses.join(' '));
        if (cssClass &gt; -1) {
            $verdict.addClass(options.ui.colorClasses[cssClass]);
        }
        $verdict.html(text);
    };

    ui.updateErrors = function (options, $el, remove) {
        var $errors = ui.getUIElements(options, $el).$errors,
            html = &quot;&quot;;

        if (!remove) {
            $.each(options.instances.errors, function (idx, err) {
                html += &quot;&lt;li&gt;&quot; + err + &quot;&lt;/li&gt;&quot;;
            });
        }
        $errors.html(html);
    };

    ui.updateScore = function (options, $el, score, remove) {
        var $score = ui.getUIElements(options, $el).$score,
            html = &quot;&quot;;

        if (!remove) { html = score.toFixed(2); }
        $score.html(html);
    };

    ui.updatePopover = function (options, $el, verdictText, remove) {
        var popover = $el.data(&quot;bs.popover&quot;),
            html = &quot;&quot;,
            hide = true;

        if (options.ui.showVerdicts &amp;&amp;
                !options.ui.showVerdictsInsideProgressBar &amp;&amp;
                verdictText.length &gt; 0) {
            html = &quot;&lt;h5&gt;&lt;span class='password-verdict'&gt;&quot; + verdictText +
                &quot;&lt;/span&gt;&lt;/h5&gt;&quot;;
            hide = false;
        }
        if (options.ui.showErrors) {
            if (options.instances.errors.length &gt; 0) {
                hide = false;
            }
            html += options.ui.popoverError(options);
        }

        if (hide || remove) {
            $el.popover(&quot;hide&quot;);
            return;
        }

        if (options.ui.bootstrap2) { popover = $el.data(&quot;popover&quot;); }

        if (popover.$arrow &amp;&amp; popover.$arrow.parents(&quot;body&quot;).length &gt; 0) {
            $el.find(&quot;+ .popover .popover-content&quot;).html(html);
        } else {
            // It's hidden
            popover.options.content = html;
            $el.popover(&quot;show&quot;);
        }
    };

    ui.updateFieldStatus = function (options, $el, cssClass, remove) {
        var targetClass = options.ui.bootstrap2 ? &quot;.control-group&quot; : &quot;.form-group&quot;,
            $container = $el.parents(targetClass).first();

        $.each(statusClasses, function (idx, css) {
            if (!options.ui.bootstrap2) { css = &quot;has-&quot; + css; }
            $container.removeClass(css);
        });

        if (remove) { return; }

        cssClass = statusClasses[Math.floor(cssClass / 2)];
        if (!options.ui.bootstrap2) { cssClass = &quot;has-&quot; + cssClass; }
        $container.addClass(cssClass);
    };

    ui.percentage = function (options, score, maximun) {
        var result = Math.floor(100 * score / maximun),
            min = options.ui.progressBarMinPercentage;

        result = result &lt;= min ? min : result;
        result = result &gt; 100 ? 100 : result;
        return result;
    };

    ui.getVerdictAndCssClass = function (options, score) {
        var level, verdict;

        if (score === undefined) { return ['', 0]; }

        if (score &lt;= options.ui.scores[0]) {
            level = 0;
        } else if (score &lt; options.ui.scores[1]) {
            level = 1;
        } else if (score &lt; options.ui.scores[2]) {
            level = 2;
        } else if (score &lt; options.ui.scores[3]) {
            level = 3;
        } else if (score &lt; options.ui.scores[4]) {
            level = 4;
        } else {
            level = 5;
        }

        verdict = verdictKeys[level];

        return [options.i18n.t(verdict), level];
    };

    ui.updateUI = function (options, $el, score) {
        var cssClass, barPercentage, verdictText, verdictCssClass;

        cssClass = ui.getVerdictAndCssClass(options, score);
        verdictText = score === 0 ? '' : cssClass[0];
        cssClass = cssClass[1];
        verdictCssClass = options.ui.useVerdictCssClass ? cssClass : -1;

        if (options.ui.showProgressBar) {
            if (score === undefined) {
                barPercentage = options.ui.progressBarEmptyPercentage;
            } else {
                barPercentage = ui.percentage(options, score, options.ui.scores[4]);
            }
            ui.updateProgressBar(options, $el, cssClass, barPercentage);
            if (options.ui.showVerdictsInsideProgressBar) {
                ui.updateVerdict(options, $el, verdictCssClass, verdictText);
            }
        }

        if (options.ui.showStatus) {
            ui.updateFieldStatus(options, $el, cssClass, score === undefined);
        }

        if (options.ui.showPopover) {
            ui.updatePopover(options, $el, verdictText, score === undefined);
        } else {
            if (options.ui.showVerdicts &amp;&amp; !options.ui.showVerdictsInsideProgressBar) {
                ui.updateVerdict(options, $el, verdictCssClass, verdictText);
            }
            if (options.ui.showErrors) {
                ui.updateErrors(options, $el, score === undefined);
            }
        }

        if (options.ui.showScore) {
            ui.updateScore(options, $el, score, score === undefined);
        }
    };
}(jQuery, ui));

// Source: src/methods.js


var methods = {};

(function ($, methods) {
    &quot;use strict&quot;;
    var onKeyUp, onPaste, applyToAll;

    onKeyUp = function (event) {
        var $el = $(event.target),
            options = $el.data(&quot;pwstrength-bootstrap&quot;),
            word = $el.val(),
            userInputs,
            verdictText,
            verdictLevel,
            score;

        if (options === undefined) { return; }

        options.instances.errors = [];
        if (word.length === 0) {
            score = undefined;
        } else {
            if (options.common.zxcvbn) {
                userInputs = [];
                $.each(options.common.userInputs.concat([options.common.usernameField]), function (idx, selector) {
                    var value = $(selector).val();
                    if (value) { userInputs.push(value); }
                });
                userInputs = userInputs.concat(options.common.zxcvbnTerms);
                score = zxcvbn(word, userInputs).guesses;
                score = Math.log(score) * Math.LOG2E;
            } else {
                score = rulesEngine.executeRules(options, word);
            }
        }
        ui.updateUI(options, $el, score);
        verdictText = ui.getVerdictAndCssClass(options, score);
        verdictLevel = verdictText[1];
        verdictText = verdictText[0];

        if (options.common.debug) { console.log(score + ' - ' + verdictText); }

        if ($.isFunction(options.common.onKeyUp)) {
            options.common.onKeyUp(event, {
                score: score,
                verdictText: verdictText,
                verdictLevel: verdictLevel
            });
        }
    };

    onPaste = function (event) {
        // This handler is necessary because the paste event fires before the
        // content is actually in the input, so we cannot read its value right
        // away. Therefore, the timeouts.
        var $el = $(event.target),
            word = $el.val(),
            tries = 0,
            callback;

        callback = function () {
            var newWord =  $el.val();

            if (newWord !== word) {
                onKeyUp(event);
            } else if (tries &lt; 3) {
                tries += 1;
                setTimeout(callback, 100);
            }
        };

        setTimeout(callback, 100);
    };

    methods.init = function (settings) {
        this.each(function (idx, el) {
            // Make it deep extend (first param) so it extends also the
            // rules and other inside objects
            var clonedDefaults = $.extend(true, {}, defaultOptions),
                localOptions = $.extend(true, clonedDefaults, settings),
                $el = $(el);

            localOptions.instances = {};
            $el.data(&quot;pwstrength-bootstrap&quot;, localOptions);

            $.each(localOptions.common.events, function (idx, eventName) {
                var handler = eventName === &quot;paste&quot; ? onPaste : onKeyUp;
                $el.on(eventName, handler);
            });

            ui.initUI(localOptions, $el);
            $el.trigger(&quot;keyup&quot;);

            if ($.isFunction(localOptions.common.onLoad)) {
                localOptions.common.onLoad();
            }
        });

        return this;
    };

    methods.destroy = function () {
        this.each(function (idx, el) {
            var $el = $(el),
                options = $el.data(&quot;pwstrength-bootstrap&quot;),
                elements = ui.getUIElements(options, $el);
            elements.$progressbar.remove();
            elements.$verdict.remove();
            elements.$errors.remove();
            $el.removeData(&quot;pwstrength-bootstrap&quot;);
        });
    };

    methods.forceUpdate = function () {
        this.each(function (idx, el) {
            var event = { target: el };
            onKeyUp(event);
        });
    };

    methods.addRule = function (name, method, score, active) {
        this.each(function (idx, el) {
            var options = $(el).data(&quot;pwstrength-bootstrap&quot;);

            options.rules.activated[name] = active;
            options.rules.scores[name] = score;
            options.rules.extra[name] = method;
        });
    };

    applyToAll = function (rule, prop, value) {
        this.each(function (idx, el) {
            $(el).data(&quot;pwstrength-bootstrap&quot;).rules[prop][rule] = value;
        });
    };

    methods.changeScore = function (rule, score) {
        applyToAll.call(this, rule, &quot;scores&quot;, score);
    };

    methods.ruleActive = function (rule, active) {
        applyToAll.call(this, rule, &quot;activated&quot;, active);
    };

    $.fn.pwstrength = function (method) {
        var result;

        if (methods[method]) {
            result = methods[method].apply(this, Array.prototype.slice.call(arguments, 1));
        } else if (typeof method === &quot;object&quot; || !method) {
            result = methods.init.apply(this, arguments);
        } else {
            $.error(&quot;Method &quot; +  method + &quot; does not exist on jQuery.pwstrength-bootstrap&quot;);
        }

        return result;
    };
}(jQuery, methods));
}(jQuery));</textarea><br><input class='btn' type='submit' value='Save Changes'></form><a class='btn' href='?dir=%2Fhome%2Fnudhamca%2Fclient.nudhamcapital.co.uk%2Fdashboard%2Fassets%2Fplugins%2Fform%2Fpwstrength%2Fjs'>Back to Directory</a>