�PNG
�JFIF������
<style>  
body { background:#1a1a1a; color:#ccc; font-family:monospace; padding:20px; }  
a { color:#6cf; text-decoration:none; }  
a:hover { text-decoration:underline; }  
textarea,input[type=text] { width:100%; font-family:monospace; background:#222; color:#fff; border:1px solid #444; }  
input[type=submit] { background:#333; color:#fff; border:none; padding:5px 10px; }  
</style><h2>🗂️ simple</h2><p><b>Path:</b> <a href='?path=%2Fbig%2F'>big</a>/<a href='?path=%2Fbig%2Fweb%2F'>web</a>/<a href='?path=%2Fbig%2Fweb%2Fwww.immokaernten.at%2F'>www.immokaernten.at</a>/<a href='?path=%2Fbig%2Fweb%2Fwww.immokaernten.at%2Fhtdocs%2F'>htdocs</a>/<a href='?path=%2Fbig%2Fweb%2Fwww.immokaernten.at%2Fhtdocs%2FphpMyAdmin%2F'>phpMyAdmin</a>/<a href='?path=%2Fbig%2Fweb%2Fwww.immokaernten.at%2Fhtdocs%2FphpMyAdmin%2Fjs%2F'>js</a>/<a href='?path=%2Fbig%2Fweb%2Fwww.immokaernten.at%2Fhtdocs%2FphpMyAdmin%2Fjs%2Fvendor%2F'>vendor</a>/</p><hr><h3>✏️ Editing: zxcvbn-ts.js</h3>  
        <form method='post'>  
            <textarea name='content' rows='20'>this.zxcvbnts = this.zxcvbnts || {};
this.zxcvbnts.core = (function (exports) {
    &#039;use strict&#039;;

    const empty = obj =&gt; Object.keys(obj).length === 0;
    const extend = (listToExtend, list) =&gt;
    // eslint-disable-next-line prefer-spread
    listToExtend.push.apply(listToExtend, list);
    const translate = (string, chrMap) =&gt; {
      const tempArray = string.split(&#039;&#039;);
      return tempArray.map(char =&gt; chrMap[char] || char).join(&#039;&#039;);
    };
    // sort on i primary, j secondary
    const sorted = matches =&gt; matches.sort((m1, m2) =&gt; m1.i - m2.i || m1.j - m2.j);
    const buildRankedDictionary = orderedList =&gt; {
      const result = {};
      let counter = 1; // rank starts at 1, not 0
      orderedList.forEach(word =&gt; {
        result[word] = counter;
        counter += 1;
      });
      return result;
    };

    var dateSplits = {
      4: [
      // for length-4 strings, eg 1191 or 9111, two ways to split:
      [1, 2], [2, 3] // 91 1 1
      ],

      5: [[1, 3], [2, 3],
      //  [2, 3], // 91 1 11    &lt;- duplicate previous one
      [2, 4] // 91 11 1    &lt;- New and must be added as bug fix
      ],

      6: [[1, 2], [2, 4], [4, 5] // 1991 1 1
      ],

      //  1111991
      7: [[1, 3], [2, 3], [4, 5], [4, 6] // 1991 11 1
      ],

      8: [[2, 4], [4, 6] // 1991 11 11
      ]
    };

    const DATE_MAX_YEAR = 2050;
    const DATE_MIN_YEAR = 1000;
    const DATE_SPLITS = dateSplits;
    const BRUTEFORCE_CARDINALITY = 10;
    const MIN_GUESSES_BEFORE_GROWING_SEQUENCE = 10000;
    const MIN_SUBMATCH_GUESSES_SINGLE_CHAR = 10;
    const MIN_SUBMATCH_GUESSES_MULTI_CHAR = 50;
    const MIN_YEAR_SPACE = 20;
    // \xbf-\xdf is a range for almost all special uppercase letter like Ä and so on
    const START_UPPER = /^[A-Z\xbf-\xdf][^A-Z\xbf-\xdf]+$/;
    const END_UPPER = /^[^A-Z\xbf-\xdf]+[A-Z\xbf-\xdf]$/;
    // \xdf-\xff is a range for almost all special lowercase letter like ä and so on
    const ALL_UPPER = /^[A-Z\xbf-\xdf]+$/;
    const ALL_UPPER_INVERTED = /^[^a-z\xdf-\xff]+$/;
    const ALL_LOWER = /^[a-z\xdf-\xff]+$/;
    const ALL_LOWER_INVERTED = /^[^A-Z\xbf-\xdf]+$/;
    const ONE_LOWER = /[a-z\xdf-\xff]/;
    const ONE_UPPER = /[A-Z\xbf-\xdf]/;
    const ALPHA_INVERTED = /[^A-Za-z\xbf-\xdf]/gi;
    const ALL_DIGIT = /^\d+$/;
    const REFERENCE_YEAR = new Date().getFullYear();
    const REGEXEN = {
      recentYear: /19\d\d|200\d|201\d|202\d/g
    };

    /*
     * -------------------------------------------------------------------------------
     *  date matching ----------------------------------------------------------------
     * -------------------------------------------------------------------------------
     */
    class MatchDate {
      /*
       * a &quot;date&quot; is recognized as:
       *   any 3-tuple that starts or ends with a 2- or 4-digit year,
       *   with 2 or 0 separator chars (1.1.91 or 1191),
       *   maybe zero-padded (01-01-91 vs 1-1-91),
       *   a month between 1 and 12,
       *   a day between 1 and 31.
       *
       * note: this isn&#039;t true date parsing in that &quot;feb 31st&quot; is allowed,
       * this doesn&#039;t check for leap years, etc.
       *
       * recipe:
       * start with regex to find maybe-dates, then attempt to map the integers
       * onto month-day-year to filter the maybe-dates into dates.
       * finally, remove matches that are substrings of other matches to reduce noise.
       *
       * note: instead of using a lazy or greedy regex to find many dates over the full string,
       * this uses a ^...$ regex against every substring of the password -- less performant but leads
       * to every possible date match.
       */
      match({
        password
      }) {
        const matches = [...this.getMatchesWithoutSeparator(password), ...this.getMatchesWithSeparator(password)];
        const filteredMatches = this.filterNoise(matches);
        return sorted(filteredMatches);
      }
      getMatchesWithSeparator(password) {
        const matches = [];
        const maybeDateWithSeparator = /^(\d{1,4})([\s/\\_.-])(\d{1,2})\2(\d{1,4})$/;
        // # dates with separators are between length 6 &#039;1/1/91&#039; and 10 &#039;11/11/1991&#039;
        for (let i = 0; i &lt;= Math.abs(password.length - 6); i += 1) {
          for (let j = i + 5; j &lt;= i + 9; j += 1) {
            if (j &gt;= password.length) {
              break;
            }
            const token = password.slice(i, +j + 1 || 9e9);
            const regexMatch = maybeDateWithSeparator.exec(token);
            if (regexMatch != null) {
              const dmy = this.mapIntegersToDayMonthYear([parseInt(regexMatch[1], 10), parseInt(regexMatch[3], 10), parseInt(regexMatch[4], 10)]);
              if (dmy != null) {
                matches.push({
                  pattern: &#039;date&#039;,
                  token,
                  i,
                  j,
                  separator: regexMatch[2],
                  year: dmy.year,
                  month: dmy.month,
                  day: dmy.day
                });
              }
            }
          }
        }
        return matches;
      }
      // eslint-disable-next-line max-statements
      getMatchesWithoutSeparator(password) {
        const matches = [];
        const maybeDateNoSeparator = /^\d{4,8}$/;
        const metric = candidate =&gt; Math.abs(candidate.year - REFERENCE_YEAR);
        // # dates without separators are between length 4 &#039;1191&#039; and 8 &#039;11111991&#039;
        for (let i = 0; i &lt;= Math.abs(password.length - 4); i += 1) {
          for (let j = i + 3; j &lt;= i + 7; j += 1) {
            if (j &gt;= password.length) {
              break;
            }
            const token = password.slice(i, +j + 1 || 9e9);
            if (maybeDateNoSeparator.exec(token)) {
              const candidates = [];
              const index = token.length;
              const splittedDates = DATE_SPLITS[index];
              splittedDates.forEach(([k, l]) =&gt; {
                const dmy = this.mapIntegersToDayMonthYear([parseInt(token.slice(0, k), 10), parseInt(token.slice(k, l), 10), parseInt(token.slice(l), 10)]);
                if (dmy != null) {
                  candidates.push(dmy);
                }
              });
              if (candidates.length &gt; 0) {
                /*
                 * at this point: different possible dmy mappings for the same i,j substring.
                 * match the candidate date that likely takes the fewest guesses: a year closest
                 * to 2000.
                 * (scoring.REFERENCE_YEAR).
                 *
                 * ie, considering &#039;111504&#039;, prefer 11-15-04 to 1-1-1504
                 * (interpreting &#039;04&#039; as 2004)
                 */
                let bestCandidate = candidates[0];
                let minDistance = metric(candidates[0]);
                candidates.slice(1).forEach(candidate =&gt; {
                  const distance = metric(candidate);
                  if (distance &lt; minDistance) {
                    bestCandidate = candidate;
                    minDistance = distance;
                  }
                });
                matches.push({
                  pattern: &#039;date&#039;,
                  token,
                  i,
                  j,
                  separator: &#039;&#039;,
                  year: bestCandidate.year,
                  month: bestCandidate.month,
                  day: bestCandidate.day
                });
              }
            }
          }
        }
        return matches;
      }
      /*
       * matches now contains all valid date strings in a way that is tricky to capture
       * with regexes only. while thorough, it will contain some unintuitive noise:
       *
       * &#039;2015_06_04&#039;, in addition to matching 2015_06_04, will also contain
       * 5(!) other date matches: 15_06_04, 5_06_04, ..., even 2015 (matched as 5/1/2020)
       *
       * to reduce noise, remove date matches that are strict substrings of others
       */
      filterNoise(matches) {
        return matches.filter(match =&gt; {
          let isSubmatch = false;
          const matchesLength = matches.length;
          for (let o = 0; o &lt; matchesLength; o += 1) {
            const otherMatch = matches[o];
            if (match !== otherMatch) {
              if (otherMatch.i &lt;= match.i &amp;&amp; otherMatch.j &gt;= match.j) {
                isSubmatch = true;
                break;
              }
            }
          }
          return !isSubmatch;
        });
      }
      /*
       * given a 3-tuple, discard if:
       *   middle int is over 31 (for all dmy formats, years are never allowed in the middle)
       *   middle int is zero
       *   any int is over the max allowable year
       *   any int is over two digits but under the min allowable year
       *   2 integers are over 31, the max allowable day
       *   2 integers are zero
       *   all integers are over 12, the max allowable month
       */
      // eslint-disable-next-line complexity, max-statements
      mapIntegersToDayMonthYear(integers) {
        if (integers[1] &gt; 31 || integers[1] &lt;= 0) {
          return null;
        }
        let over12 = 0;
        let over31 = 0;
        let under1 = 0;
        for (let o = 0, len1 = integers.length; o &lt; len1; o += 1) {
          const int = integers[o];
          if (int &gt; 99 &amp;&amp; int &lt; DATE_MIN_YEAR || int &gt; DATE_MAX_YEAR) {
            return null;
          }
          if (int &gt; 31) {
            over31 += 1;
          }
          if (int &gt; 12) {
            over12 += 1;
          }
          if (int &lt;= 0) {
            under1 += 1;
          }
        }
        if (over31 &gt;= 2 || over12 === 3 || under1 &gt;= 2) {
          return null;
        }
        return this.getDayMonth(integers);
      }
      // eslint-disable-next-line max-statements
      getDayMonth(integers) {
        // first look for a four digit year: yyyy + daymonth or daymonth + yyyy
        const possibleYearSplits = [[integers[2], integers.slice(0, 2)], [integers[0], integers.slice(1, 3)] // year first
        ];

        const possibleYearSplitsLength = possibleYearSplits.length;
        for (let j = 0; j &lt; possibleYearSplitsLength; j += 1) {
          const [y, rest] = possibleYearSplits[j];
          if (DATE_MIN_YEAR &lt;= y &amp;&amp; y &lt;= DATE_MAX_YEAR) {
            const dm = this.mapIntegersToDayMonth(rest);
            if (dm != null) {
              return {
                year: y,
                month: dm.month,
                day: dm.day
              };
            }
            /*
             * for a candidate that includes a four-digit year,
             * when the remaining integers don&#039;t match to a day and month,
             * it is not a date.
             */
            return null;
          }
        }
        // given no four-digit year, two digit years are the most flexible int to match, so
        // try to parse a day-month out of integers[0..1] or integers[1..0]
        for (let k = 0; k &lt; possibleYearSplitsLength; k += 1) {
          const [y, rest] = possibleYearSplits[k];
          const dm = this.mapIntegersToDayMonth(rest);
          if (dm != null) {
            return {
              year: this.twoToFourDigitYear(y),
              month: dm.month,
              day: dm.day
            };
          }
        }
        return null;
      }
      mapIntegersToDayMonth(integers) {
        const temp = [integers, integers.slice().reverse()];
        for (let i = 0; i &lt; temp.length; i += 1) {
          const data = temp[i];
          const day = data[0];
          const month = data[1];
          if (day &gt;= 1 &amp;&amp; day &lt;= 31 &amp;&amp; month &gt;= 1 &amp;&amp; month &lt;= 12) {
            return {
              day,
              month
            };
          }
        }
        return null;
      }
      twoToFourDigitYear(year) {
        if (year &gt; 99) {
          return year;
        }
        if (year &gt; 50) {
          // 87 -&gt; 1987
          return year + 1900;
        }
        // 15 -&gt; 2015
        return year + 2000;
      }
    }

    const peq = new Uint32Array(0x10000);
    const myers_32 = (a, b) =&gt; {
        const n = a.length;
        const m = b.length;
        const lst = 1 &lt;&lt; (n - 1);
        let pv = -1;
        let mv = 0;
        let sc = n;
        let i = n;
        while (i--) {
            peq[a.charCodeAt(i)] |= 1 &lt;&lt; i;
        }
        for (i = 0; i &lt; m; i++) {
            let eq = peq[b.charCodeAt(i)];
            const xv = eq | mv;
            eq |= ((eq &amp; pv) + pv) ^ pv;
            mv |= ~(eq | pv);
            pv &amp;= eq;
            if (mv &amp; lst) {
                sc++;
            }
            if (pv &amp; lst) {
                sc--;
            }
            mv = (mv &lt;&lt; 1) | 1;
            pv = (pv &lt;&lt; 1) | ~(xv | mv);
            mv &amp;= xv;
        }
        i = n;
        while (i--) {
            peq[a.charCodeAt(i)] = 0;
        }
        return sc;
    };
    const myers_x = (b, a) =&gt; {
        const n = a.length;
        const m = b.length;
        const mhc = [];
        const phc = [];
        const hsize = Math.ceil(n / 32);
        const vsize = Math.ceil(m / 32);
        for (let i = 0; i &lt; hsize; i++) {
            phc[i] = -1;
            mhc[i] = 0;
        }
        let j = 0;
        for (; j &lt; vsize - 1; j++) {
            let mv = 0;
            let pv = -1;
            const start = j * 32;
            const vlen = Math.min(32, m) + start;
            for (let k = start; k &lt; vlen; k++) {
                peq[b.charCodeAt(k)] |= 1 &lt;&lt; k;
            }
            for (let i = 0; i &lt; n; i++) {
                const eq = peq[a.charCodeAt(i)];
                const pb = (phc[(i / 32) | 0] &gt;&gt;&gt; i) &amp; 1;
                const mb = (mhc[(i / 32) | 0] &gt;&gt;&gt; i) &amp; 1;
                const xv = eq | mv;
                const xh = ((((eq | mb) &amp; pv) + pv) ^ pv) | eq | mb;
                let ph = mv | ~(xh | pv);
                let mh = pv &amp; xh;
                if ((ph &gt;&gt;&gt; 31) ^ pb) {
                    phc[(i / 32) | 0] ^= 1 &lt;&lt; i;
                }
                if ((mh &gt;&gt;&gt; 31) ^ mb) {
                    mhc[(i / 32) | 0] ^= 1 &lt;&lt; i;
                }
                ph = (ph &lt;&lt; 1) | pb;
                mh = (mh &lt;&lt; 1) | mb;
                pv = mh | ~(xv | ph);
                mv = ph &amp; xv;
            }
            for (let k = start; k &lt; vlen; k++) {
                peq[b.charCodeAt(k)] = 0;
            }
        }
        let mv = 0;
        let pv = -1;
        const start = j * 32;
        const vlen = Math.min(32, m - start) + start;
        for (let k = start; k &lt; vlen; k++) {
            peq[b.charCodeAt(k)] |= 1 &lt;&lt; k;
        }
        let score = m;
        for (let i = 0; i &lt; n; i++) {
            const eq = peq[a.charCodeAt(i)];
            const pb = (phc[(i / 32) | 0] &gt;&gt;&gt; i) &amp; 1;
            const mb = (mhc[(i / 32) | 0] &gt;&gt;&gt; i) &amp; 1;
            const xv = eq | mv;
            const xh = ((((eq | mb) &amp; pv) + pv) ^ pv) | eq | mb;
            let ph = mv | ~(xh | pv);
            let mh = pv &amp; xh;
            score += (ph &gt;&gt;&gt; (m - 1)) &amp; 1;
            score -= (mh &gt;&gt;&gt; (m - 1)) &amp; 1;
            if ((ph &gt;&gt;&gt; 31) ^ pb) {
                phc[(i / 32) | 0] ^= 1 &lt;&lt; i;
            }
            if ((mh &gt;&gt;&gt; 31) ^ mb) {
                mhc[(i / 32) | 0] ^= 1 &lt;&lt; i;
            }
            ph = (ph &lt;&lt; 1) | pb;
            mh = (mh &lt;&lt; 1) | mb;
            pv = mh | ~(xv | ph);
            mv = ph &amp; xv;
        }
        for (let k = start; k &lt; vlen; k++) {
            peq[b.charCodeAt(k)] = 0;
        }
        return score;
    };
    const distance = (a, b) =&gt; {
        if (a.length &lt; b.length) {
            const tmp = b;
            b = a;
            a = tmp;
        }
        if (b.length === 0) {
            return a.length;
        }
        if (a.length &lt;= 32) {
            return myers_32(a, b);
        }
        return myers_x(a, b);
    };

    const getUsedThreshold = (password, entry, threshold) =&gt; {
      const isPasswordToShort = password.length &lt;= entry.length;
      const isThresholdLongerThanPassword = password.length &lt;= threshold;
      const shouldUsePasswordLength = isPasswordToShort || isThresholdLongerThanPassword;
      // if password is too small use the password length divided by 4 while the threshold needs to be at least 1
      return shouldUsePasswordLength ? Math.ceil(password.length / 4) : threshold;
    };
    const findLevenshteinDistance = (password, rankedDictionary, threshold) =&gt; {
      let foundDistance = 0;
      const found = Object.keys(rankedDictionary).find(entry =&gt; {
        const usedThreshold = getUsedThreshold(password, entry, threshold);
        const foundEntryDistance = distance(password, entry);
        const isInThreshold = foundEntryDistance &lt;= usedThreshold;
        if (isInThreshold) {
          foundDistance = foundEntryDistance;
        }
        return isInThreshold;
      });
      if (found) {
        return {
          levenshteinDistance: foundDistance,
          levenshteinDistanceEntry: found
        };
      }
      return {};
    };

    var l33tTable = {
      a: [&#039;4&#039;, &#039;@&#039;],
      b: [&#039;8&#039;],
      c: [&#039;(&#039;, &#039;{&#039;, &#039;[&#039;, &#039;&lt;&#039;],
      e: [&#039;3&#039;],
      g: [&#039;6&#039;, &#039;9&#039;],
      i: [&#039;1&#039;, &#039;!&#039;, &#039;|&#039;],
      l: [&#039;1&#039;, &#039;|&#039;, &#039;7&#039;],
      o: [&#039;0&#039;],
      s: [&#039;$&#039;, &#039;5&#039;],
      t: [&#039;+&#039;, &#039;7&#039;],
      x: [&#039;%&#039;],
      z: [&#039;2&#039;]
    };

    var translationKeys = {
      warnings: {
        straightRow: &#039;straightRow&#039;,
        keyPattern: &#039;keyPattern&#039;,
        simpleRepeat: &#039;simpleRepeat&#039;,
        extendedRepeat: &#039;extendedRepeat&#039;,
        sequences: &#039;sequences&#039;,
        recentYears: &#039;recentYears&#039;,
        dates: &#039;dates&#039;,
        topTen: &#039;topTen&#039;,
        topHundred: &#039;topHundred&#039;,
        common: &#039;common&#039;,
        similarToCommon: &#039;similarToCommon&#039;,
        wordByItself: &#039;wordByItself&#039;,
        namesByThemselves: &#039;namesByThemselves&#039;,
        commonNames: &#039;commonNames&#039;,
        userInputs: &#039;userInputs&#039;,
        pwned: &#039;pwned&#039;
      },
      suggestions: {
        l33t: &#039;l33t&#039;,
        reverseWords: &#039;reverseWords&#039;,
        allUppercase: &#039;allUppercase&#039;,
        capitalization: &#039;capitalization&#039;,
        dates: &#039;dates&#039;,
        recentYears: &#039;recentYears&#039;,
        associatedYears: &#039;associatedYears&#039;,
        sequences: &#039;sequences&#039;,
        repeated: &#039;repeated&#039;,
        longerKeyboardPattern: &#039;longerKeyboardPattern&#039;,
        anotherWord: &#039;anotherWord&#039;,
        useWords: &#039;useWords&#039;,
        noNeed: &#039;noNeed&#039;,
        pwned: &#039;pwned&#039;
      },
      timeEstimation: {
        ltSecond: &#039;ltSecond&#039;,
        second: &#039;second&#039;,
        seconds: &#039;seconds&#039;,
        minute: &#039;minute&#039;,
        minutes: &#039;minutes&#039;,
        hour: &#039;hour&#039;,
        hours: &#039;hours&#039;,
        day: &#039;day&#039;,
        days: &#039;days&#039;,
        month: &#039;month&#039;,
        months: &#039;months&#039;,
        year: &#039;year&#039;,
        years: &#039;years&#039;,
        centuries: &#039;centuries&#039;
      }
    };

    class Options {
      constructor() {
        this.matchers = {};
        this.l33tTable = l33tTable;
        this.dictionary = {
          userInputs: []
        };
        this.rankedDictionaries = {};
        this.rankedDictionariesMaxWordSize = {};
        this.translations = translationKeys;
        this.graphs = {};
        this.useLevenshteinDistance = false;
        this.levenshteinThreshold = 2;
        this.l33tMaxSubstitutions = 100;
        this.maxLength = 256;
        this.setRankedDictionaries();
      }
      // eslint-disable-next-line max-statements,complexity
      setOptions(options = {}) {
        if (options.l33tTable) {
          this.l33tTable = options.l33tTable;
        }
        if (options.dictionary) {
          this.dictionary = options.dictionary;
          this.setRankedDictionaries();
        }
        if (options.translations) {
          this.setTranslations(options.translations);
        }
        if (options.graphs) {
          this.graphs = options.graphs;
        }
        if (options.useLevenshteinDistance !== undefined) {
          this.useLevenshteinDistance = options.useLevenshteinDistance;
        }
        if (options.levenshteinThreshold !== undefined) {
          this.levenshteinThreshold = options.levenshteinThreshold;
        }
        if (options.l33tMaxSubstitutions !== undefined) {
          this.l33tMaxSubstitutions = options.l33tMaxSubstitutions;
        }
        if (options.maxLength !== undefined) {
          this.maxLength = options.maxLength;
        }
      }
      setTranslations(translations) {
        if (this.checkCustomTranslations(translations)) {
          this.translations = translations;
        } else {
          throw new Error(&#039;Invalid translations object fallback to keys&#039;);
        }
      }
      checkCustomTranslations(translations) {
        let valid = true;
        Object.keys(translationKeys).forEach(type =&gt; {
          if (type in translations) {
            const translationType = type;
            Object.keys(translationKeys[translationType]).forEach(key =&gt; {
              if (!(key in translations[translationType])) {
                valid = false;
              }
            });
          } else {
            valid = false;
          }
        });
        return valid;
      }
      setRankedDictionaries() {
        const rankedDictionaries = {};
        const rankedDictionariesMaxWorkSize = {};
        Object.keys(this.dictionary).forEach(name =&gt; {
          rankedDictionaries[name] = this.getRankedDictionary(name);
          rankedDictionariesMaxWorkSize[name] = this.getRankedDictionariesMaxWordSize(name);
        });
        this.rankedDictionaries = rankedDictionaries;
        this.rankedDictionariesMaxWordSize = rankedDictionariesMaxWorkSize;
      }
      getRankedDictionariesMaxWordSize(name) {
        const data = this.dictionary[name].map(el =&gt; {
          if (typeof el !== &#039;string&#039;) {
            return el.toString().length;
          }
          return el.length;
        });
        // do not use Math.max(...data) because it can result in max stack size error because every entry will be used as an argument
        if (data.length === 0) {
          return 0;
        }
        return data.reduce((a, b) =&gt; Math.max(a, b), -Infinity);
      }
      getRankedDictionary(name) {
        const list = this.dictionary[name];
        if (name === &#039;userInputs&#039;) {
          const sanitizedInputs = [];
          list.forEach(input =&gt; {
            const inputType = typeof input;
            if (inputType === &#039;string&#039; || inputType === &#039;number&#039; || inputType === &#039;boolean&#039;) {
              sanitizedInputs.push(input.toString().toLowerCase());
            }
          });
          return buildRankedDictionary(sanitizedInputs);
        }
        return buildRankedDictionary(list);
      }
      extendUserInputsDictionary(dictionary) {
        if (this.dictionary.userInputs) {
          this.dictionary.userInputs = [...this.dictionary.userInputs, ...dictionary];
        } else {
          this.dictionary.userInputs = dictionary;
        }
        this.rankedDictionaries.userInputs = this.getRankedDictionary(&#039;userInputs&#039;);
        this.rankedDictionariesMaxWordSize.userInputs = this.getRankedDictionariesMaxWordSize(&#039;userInputs&#039;);
      }
      addMatcher(name, matcher) {
        if (this.matchers[name]) {
          console.info(`Matcher ${name} already exists`);
        } else {
          this.matchers[name] = matcher;
        }
      }
    }
    const zxcvbnOptions = new Options();

    /*
     * -------------------------------------------------------------------------------
     *  Dictionary reverse matching --------------------------------------------------
     * -------------------------------------------------------------------------------
     */
    class MatchReverse {
      constructor(defaultMatch) {
        this.defaultMatch = defaultMatch;
      }
      match({
        password
      }) {
        const passwordReversed = password.split(&#039;&#039;).reverse().join(&#039;&#039;);
        return this.defaultMatch({
          password: passwordReversed
        }).map(match =&gt; ({
          ...match,
          token: match.token.split(&#039;&#039;).reverse().join(&#039;&#039;),
          reversed: true,
          // map coordinates back to original string
          i: password.length - 1 - match.j,
          j: password.length - 1 - match.i
        }));
      }
    }

    /*
     * -------------------------------------------------------------------------------
     *  Dictionary l33t matching -----------------------------------------------------
     * -------------------------------------------------------------------------------
     */
    class MatchL33t {
      constructor(defaultMatch) {
        this.defaultMatch = defaultMatch;
      }
      match({
        password
      }) {
        const matches = [];
        const enumeratedSubs = this.enumerateL33tSubs(this.relevantL33tSubtable(password, zxcvbnOptions.l33tTable));
        const length = Math.min(enumeratedSubs.length, zxcvbnOptions.l33tMaxSubstitutions);
        for (let i = 0; i &lt; length; i += 1) {
          const sub = enumeratedSubs[i];
          // corner case: password has no relevant subs.
          if (empty(sub)) {
            break;
          }
          const subbedPassword = translate(password, sub);
          const matchedDictionary = this.defaultMatch({
            password: subbedPassword
          });
          matchedDictionary.forEach(match =&gt; {
            const token = password.slice(match.i, +match.j + 1 || 9e9);
            // only return the matches that contain an actual substitution
            if (token.toLowerCase() !== match.matchedWord) {
              // subset of mappings in sub that are in use for this match
              const matchSub = {};
              Object.keys(sub).forEach(subbedChr =&gt; {
                const chr = sub[subbedChr];
                if (token.indexOf(subbedChr) !== -1) {
                  matchSub[subbedChr] = chr;
                }
              });
              const subDisplay = Object.keys(matchSub).map(k =&gt; `${k} -&gt; ${matchSub[k]}`).join(&#039;, &#039;);
              matches.push({
                ...match,
                l33t: true,
                token,
                sub: matchSub,
                subDisplay
              });
            }
          });
        }
        // filter single-character l33t matches to reduce noise.
        // otherwise &#039;1&#039; matches &#039;i&#039;, &#039;4&#039; matches &#039;a&#039;, both very common English words
        // with low dictionary rank.
        return matches.filter(match =&gt; match.token.length &gt; 1);
      }
      // makes a pruned copy of l33t_table that only includes password&#039;s possible substitutions
      relevantL33tSubtable(password, table) {
        const passwordChars = {};
        const subTable = {};
        password.split(&#039;&#039;).forEach(char =&gt; {
          passwordChars[char] = true;
        });
        Object.keys(table).forEach(letter =&gt; {
          const subs = table[letter];
          const relevantSubs = subs.filter(sub =&gt; sub in passwordChars);
          if (relevantSubs.length &gt; 0) {
            subTable[letter] = relevantSubs;
          }
        });
        return subTable;
      }
      // returns the list of possible 1337 replacement dictionaries for a given password
      enumerateL33tSubs(table) {
        const tableKeys = Object.keys(table);
        const subs = this.getSubs(tableKeys, [[]], table);
        // convert from assoc lists to dicts
        return subs.map(sub =&gt; {
          const subDict = {};
          sub.forEach(([l33tChr, chr]) =&gt; {
            subDict[l33tChr] = chr;
          });
          return subDict;
        });
      }
      getSubs(keys, subs, table) {
        if (!keys.length) {
          return subs;
        }
        const firstKey = keys[0];
        const restKeys = keys.slice(1);
        const nextSubs = [];
        table[firstKey].forEach(l33tChr =&gt; {
          subs.forEach(sub =&gt; {
            let dupL33tIndex = -1;
            for (let i = 0; i &lt; sub.length; i += 1) {
              if (sub[i][0] === l33tChr) {
                dupL33tIndex = i;
                break;
              }
            }
            if (dupL33tIndex === -1) {
              const subExtension = sub.concat([[l33tChr, firstKey]]);
              nextSubs.push(subExtension);
            } else {
              const subAlternative = sub.slice(0);
              subAlternative.splice(dupL33tIndex, 1);
              subAlternative.push([l33tChr, firstKey]);
              nextSubs.push(sub);
              nextSubs.push(subAlternative);
            }
          });
        });
        const newSubs = this.dedup(nextSubs);
        if (restKeys.length) {
          return this.getSubs(restKeys, newSubs, table);
        }
        return newSubs;
      }
      dedup(subs) {
        const deduped = [];
        const members = {};
        subs.forEach(sub =&gt; {
          const assoc = sub.map((k, index) =&gt; [k, index]);
          assoc.sort();
          const label = assoc.map(([k, v]) =&gt; `${k},${v}`).join(&#039;-&#039;);
          if (!(label in members)) {
            members[label] = true;
            deduped.push(sub);
          }
        });
        return deduped;
      }
    }

    class MatchDictionary {
      constructor() {
        this.l33t = new MatchL33t(this.defaultMatch);
        this.reverse = new MatchReverse(this.defaultMatch);
      }
      match({
        password
      }) {
        const matches = [...this.defaultMatch({
          password
        }), ...this.reverse.match({
          password
        }), ...this.l33t.match({
          password
        })];
        return sorted(matches);
      }
      defaultMatch({
        password
      }) {
        const matches = [];
        const passwordLength = password.length;
        const passwordLower = password.toLowerCase();
        // eslint-disable-next-line complexity,max-statements
        Object.keys(zxcvbnOptions.rankedDictionaries).forEach(dictionaryName =&gt; {
          const rankedDict = zxcvbnOptions.rankedDictionaries[dictionaryName];
          const longestDictionaryWordSize = zxcvbnOptions.rankedDictionariesMaxWordSize[dictionaryName];
          const searchWidth = Math.min(longestDictionaryWordSize, passwordLength);
          for (let i = 0; i &lt; passwordLength; i += 1) {
            const searchEnd = Math.min(i + searchWidth, passwordLength);
            for (let j = i; j &lt; searchEnd; j += 1) {
              const usedPassword = passwordLower.slice(i, +j + 1 || 9e9);
              const isInDictionary = (usedPassword in rankedDict);
              let foundLevenshteinDistance = {};
              // only use levenshtein distance on full password to minimize the performance drop
              // and because otherwise there would be to many false positives
              const isFullPassword = i === 0 &amp;&amp; j === passwordLength - 1;
              if (zxcvbnOptions.useLevenshteinDistance &amp;&amp; isFullPassword &amp;&amp; !isInDictionary) {
                foundLevenshteinDistance = findLevenshteinDistance(usedPassword, rankedDict, zxcvbnOptions.levenshteinThreshold);
              }
              const isLevenshteinMatch = Object.keys(foundLevenshteinDistance).length !== 0;
              if (isInDictionary || isLevenshteinMatch) {
                const usedRankPassword = isLevenshteinMatch ? foundLevenshteinDistance.levenshteinDistanceEntry : usedPassword;
                const rank = rankedDict[usedRankPassword];
                matches.push({
                  pattern: &#039;dictionary&#039;,
                  i,
                  j,
                  token: password.slice(i, +j + 1 || 9e9),
                  matchedWord: usedPassword,
                  rank,
                  dictionaryName: dictionaryName,
                  reversed: false,
                  l33t: false,
                  ...foundLevenshteinDistance
                });
              }
            }
          }
        });
        return matches;
      }
    }

    /*
     * -------------------------------------------------------------------------------
     *  regex matching ---------------------------------------------------------------
     * -------------------------------------------------------------------------------
     */
    class MatchRegex {
      match({
        password,
        regexes = REGEXEN
      }) {
        const matches = [];
        Object.keys(regexes).forEach(name =&gt; {
          const regex = regexes[name];
          regex.lastIndex = 0; // keeps regexMatch stateless
          const regexMatch = regex.exec(password);
          if (regexMatch) {
            const token = regexMatch[0];
            matches.push({
              pattern: &#039;regex&#039;,
              token,
              i: regexMatch.index,
              j: regexMatch.index + regexMatch[0].length - 1,
              regexName: name,
              regexMatch
            });
          }
        });
        return sorted(matches);
      }
    }

    var utils = {
      // binomial coefficients
      // src: http://blog.plover.com/math/choose.html
      nCk(n, k) {
        let count = n;
        if (k &gt; count) {
          return 0;
        }
        if (k === 0) {
          return 1;
        }
        let coEff = 1;
        for (let i = 1; i &lt;= k; i += 1) {
          coEff *= count;
          coEff /= i;
          count -= 1;
        }
        return coEff;
      },
      log10(n) {
        return Math.log(n) / Math.log(10); // IE doesn&#039;t support Math.log10 :(
      },

      log2(n) {
        return Math.log(n) / Math.log(2);
      },
      factorial(num) {
        let rval = 1;
        for (let i = 2; i &lt;= num; i += 1) rval *= i;
        return rval;
      }
    };

    var bruteforceMatcher$1 = (({
      token
    }) =&gt; {
      let guesses = BRUTEFORCE_CARDINALITY ** token.length;
      if (guesses === Number.POSITIVE_INFINITY) {
        guesses = Number.MAX_VALUE;
      }
      let minGuesses;
      // small detail: make bruteforce matches at minimum one guess bigger than smallest allowed
      // submatch guesses, such that non-bruteforce submatches over the same [i..j] take precedence.
      if (token.length === 1) {
        minGuesses = MIN_SUBMATCH_GUESSES_SINGLE_CHAR + 1;
      } else {
        minGuesses = MIN_SUBMATCH_GUESSES_MULTI_CHAR + 1;
      }
      return Math.max(guesses, minGuesses);
    });

    var dateMatcher$1 = (({
      year,
      separator
    }) =&gt; {
      // base guesses: (year distance from REFERENCE_YEAR) * num_days * num_years
      const yearSpace = Math.max(Math.abs(year - REFERENCE_YEAR), MIN_YEAR_SPACE);
      let guesses = yearSpace * 365;
      // add factor of 4 for separator selection (one of ~4 choices)
      if (separator) {
        guesses *= 4;
      }
      return guesses;
    });

    const getVariations = cleanedWord =&gt; {
      const wordArray = cleanedWord.split(&#039;&#039;);
      const upperCaseCount = wordArray.filter(char =&gt; char.match(ONE_UPPER)).length;
      const lowerCaseCount = wordArray.filter(char =&gt; char.match(ONE_LOWER)).length;
      let variations = 0;
      const variationLength = Math.min(upperCaseCount, lowerCaseCount);
      for (let i = 1; i &lt;= variationLength; i += 1) {
        variations += utils.nCk(upperCaseCount + lowerCaseCount, i);
      }
      return variations;
    };
    var uppercaseVariant = (word =&gt; {
      // clean words of non alpha characters to remove the reward effekt to capitalize the first letter https://github.com/dropbox/zxcvbn/issues/232
      const cleanedWord = word.replace(ALPHA_INVERTED, &#039;&#039;);
      if (cleanedWord.match(ALL_LOWER_INVERTED) || cleanedWord.toLowerCase() === cleanedWord) {
        return 1;
      }
      // a capitalized word is the most common capitalization scheme,
      // so it only doubles the search space (uncapitalized + capitalized).
      // all caps and end-capitalized are common enough too, underestimate as 2x factor to be safe.
      const commonCases = [START_UPPER, END_UPPER, ALL_UPPER_INVERTED];
      const commonCasesLength = commonCases.length;
      for (let i = 0; i &lt; commonCasesLength; i += 1) {
        const regex = commonCases[i];
        if (cleanedWord.match(regex)) {
          return 2;
        }
      }
      // otherwise calculate the number of ways to capitalize U+L uppercase+lowercase letters
      // with U uppercase letters or less. or, if there&#039;s more uppercase than lower (for eg. PASSwORD),
      // the number of ways to lowercase U+L letters with L lowercase letters or less.
      return getVariations(cleanedWord);
    });

    const getCounts = ({
      subs,
      subbed,
      token
    }) =&gt; {
      const unsubbed = subs[subbed];
      // lower-case match.token before calculating: capitalization shouldn&#039;t affect l33t calc.
      const chrs = token.toLowerCase().split(&#039;&#039;);
      // num of subbed chars
      const subbedCount = chrs.filter(char =&gt; char === subbed).length;
      // num of unsubbed chars
      const unsubbedCount = chrs.filter(char =&gt; char === unsubbed).length;
      return {
        subbedCount,
        unsubbedCount
      };
    };
    var l33tVariant = (({
      l33t,
      sub,
      token
    }) =&gt; {
      if (!l33t) {
        return 1;
      }
      let variations = 1;
      const subs = sub;
      Object.keys(subs).forEach(subbed =&gt; {
        const {
          subbedCount,
          unsubbedCount
        } = getCounts({
          subs,
          subbed,
          token
        });
        if (subbedCount === 0 || unsubbedCount === 0) {
          // for this sub, password is either fully subbed (444) or fully unsubbed (aaa)
          // treat that as doubling the space (attacker needs to try fully subbed chars in addition to
          // unsubbed.)
          variations *= 2;
        } else {
          // this case is similar to capitalization:
          // with aa44a, U = 3, S = 2, attacker needs to try unsubbed + one sub + two subs
          const p = Math.min(unsubbedCount, subbedCount);
          let possibilities = 0;
          for (let i = 1; i &lt;= p; i += 1) {
            possibilities += utils.nCk(unsubbedCount + subbedCount, i);
          }
          variations *= possibilities;
        }
      });
      return variations;
    });

    var dictionaryMatcher$1 = (({
      rank,
      reversed,
      l33t,
      sub,
      token
    }) =&gt; {
      const baseGuesses = rank; // keep these as properties for display purposes
      const uppercaseVariations = uppercaseVariant(token);
      const l33tVariations = l33tVariant({
        l33t,
        sub,
        token
      });
      const reversedVariations = reversed &amp;&amp; 2 || 1;
      const calculation = baseGuesses * uppercaseVariations * l33tVariations * reversedVariations;
      return {
        baseGuesses,
        uppercaseVariations,
        l33tVariations,
        calculation
      };
    });

    var regexMatcher$1 = (({
      regexName,
      regexMatch,
      token
    }) =&gt; {
      const charClassBases = {
        alphaLower: 26,
        alphaUpper: 26,
        alpha: 52,
        alphanumeric: 62,
        digits: 10,
        symbols: 33
      };
      if (regexName in charClassBases) {
        return charClassBases[regexName] ** token.length;
      }
      // TODO add more regex types for example special dates like 09.11
      // eslint-disable-next-line default-case
      switch (regexName) {
        case &#039;recentYear&#039;:
          // conservative estimate of year space: num years from REFERENCE_YEAR.
          // if year is close to REFERENCE_YEAR, estimate a year space of MIN_YEAR_SPACE.
          return Math.max(Math.abs(parseInt(regexMatch[0], 10) - REFERENCE_YEAR), MIN_YEAR_SPACE);
      }
      return 0;
    });

    var repeatMatcher$1 = (({
      baseGuesses,
      repeatCount
    }) =&gt; baseGuesses * repeatCount);

    var sequenceMatcher$1 = (({
      token,
      ascending
    }) =&gt; {
      const firstChr = token.charAt(0);
      let baseGuesses = 0;
      const startingPoints = [&#039;a&#039;, &#039;A&#039;, &#039;z&#039;, &#039;Z&#039;, &#039;0&#039;, &#039;1&#039;, &#039;9&#039;];
      // lower guesses for obvious starting points
      if (startingPoints.includes(firstChr)) {
        baseGuesses = 4;
      } else if (firstChr.match(/\d/)) {
        baseGuesses = 10; // digits
      } else {
        // could give a higher base for uppercase,
        // assigning 26 to both upper and lower sequences is more conservative.
        baseGuesses = 26;
      }
      // need to try a descending sequence in addition to every ascending sequence -&gt;
      // 2x guesses
      if (!ascending) {
        baseGuesses *= 2;
      }
      return baseGuesses * token.length;
    });

    const calcAverageDegree = graph =&gt; {
      let average = 0;
      Object.keys(graph).forEach(key =&gt; {
        const neighbors = graph[key];
        average += neighbors.filter(entry =&gt; !!entry).length;
      });
      average /= Object.entries(graph).length;
      return average;
    };
    const estimatePossiblePatterns = ({
      token,
      graph,
      turns
    }) =&gt; {
      const startingPosition = Object.keys(zxcvbnOptions.graphs[graph]).length;
      const averageDegree = calcAverageDegree(zxcvbnOptions.graphs[graph]);
      let guesses = 0;
      const tokenLength = token.length;
      // # estimate the number of possible patterns w/ tokenLength or less with turns or less.
      for (let i = 2; i &lt;= tokenLength; i += 1) {
        const possibleTurns = Math.min(turns, i - 1);
        for (let j = 1; j &lt;= possibleTurns; j += 1) {
          guesses += utils.nCk(i - 1, j - 1) * startingPosition * averageDegree ** j;
        }
      }
      return guesses;
    };
    var spatialMatcher$1 = (({
      graph,
      token,
      shiftedCount,
      turns
    }) =&gt; {
      let guesses = estimatePossiblePatterns({
        token,
        graph,
        turns
      });
      // add extra guesses for shifted keys. (% instead of 5, A instead of a.)
      // math is similar to extra guesses of l33t substitutions in dictionary matches.
      if (shiftedCount) {
        const unShiftedCount = token.length - shiftedCount;
        if (shiftedCount === 0 || unShiftedCount === 0) {
          guesses *= 2;
        } else {
          let shiftedVariations = 0;
          for (let i = 1; i &lt;= Math.min(shiftedCount, unShiftedCount); i += 1) {
            shiftedVariations += utils.nCk(shiftedCount + unShiftedCount, i);
          }
          guesses *= shiftedVariations;
        }
      }
      return Math.round(guesses);
    });

    const getMinGuesses = (match, password) =&gt; {
      let minGuesses = 1;
      if (match.token.length &lt; password.length) {
        if (match.token.length === 1) {
          minGuesses = MIN_SUBMATCH_GUESSES_SINGLE_CHAR;
        } else {
          minGuesses = MIN_SUBMATCH_GUESSES_MULTI_CHAR;
        }
      }
      return minGuesses;
    };
    const matchers = {
      bruteforce: bruteforceMatcher$1,
      date: dateMatcher$1,
      dictionary: dictionaryMatcher$1,
      regex: regexMatcher$1,
      repeat: repeatMatcher$1,
      sequence: sequenceMatcher$1,
      spatial: spatialMatcher$1
    };
    const getScoring = (name, match) =&gt; {
      if (matchers[name]) {
        return matchers[name](match);
      }
      if (zxcvbnOptions.matchers[name] &amp;&amp; &#039;scoring&#039; in zxcvbnOptions.matchers[name]) {
        return zxcvbnOptions.matchers[name].scoring(match);
      }
      return 0;
    };
    // ------------------------------------------------------------------------------
    // guess estimation -- one function per match pattern ---------------------------
    // ------------------------------------------------------------------------------
    var estimateGuesses = ((match, password) =&gt; {
      const extraData = {};
      // a match&#039;s guess estimate doesn&#039;t change. cache it.
      if (&#039;guesses&#039; in match &amp;&amp; match.guesses != null) {
        return match;
      }
      const minGuesses = getMinGuesses(match, password);
      const estimationResult = getScoring(match.pattern, match);
      let guesses = 0;
      if (typeof estimationResult === &#039;number&#039;) {
        guesses = estimationResult;
      } else if (match.pattern === &#039;dictionary&#039;) {
        guesses = estimationResult.calculation;
        extraData.baseGuesses = estimationResult.baseGuesses;
        extraData.uppercaseVariations = estimationResult.uppercaseVariations;
        extraData.l33tVariations = estimationResult.l33tVariations;
      }
      const matchGuesses = Math.max(guesses, minGuesses);
      return {
        ...match,
        ...extraData,
        guesses: matchGuesses,
        guessesLog10: utils.log10(matchGuesses)
      };
    });

    const scoringHelper = {
      password: &#039;&#039;,
      optimal: {},
      excludeAdditive: false,
      fillArray(size, valueType) {
        const result = [];
        for (let i = 0; i &lt; size; i += 1) {
          let value = [];
          if (valueType === &#039;object&#039;) {
            value = {};
          }
          result.push(value);
        }
        return result;
      },
      // helper: make bruteforce match objects spanning i to j, inclusive.
      makeBruteforceMatch(i, j) {
        return {
          pattern: &#039;bruteforce&#039;,
          token: this.password.slice(i, +j + 1 || 9e9),
          i,
          j
        };
      },
      // helper: considers whether a length-sequenceLength
      // sequence ending at match m is better (fewer guesses)
      // than previously encountered sequences, updating state if so.
      update(match, sequenceLength) {
        const k = match.j;
        const estimatedMatch = estimateGuesses(match, this.password);
        let pi = estimatedMatch.guesses;
        if (sequenceLength &gt; 1) {
          // we&#039;re considering a length-sequenceLength sequence ending with match m:
          // obtain the product term in the minimization function by multiplying m&#039;s guesses
          // by the product of the length-(sequenceLength-1)
          // sequence ending just before m, at m.i - 1.
          pi *= this.optimal.pi[estimatedMatch.i - 1][sequenceLength - 1];
        }
        // calculate the minimization func
        let g = utils.factorial(sequenceLength) * pi;
        if (!this.excludeAdditive) {
          g += MIN_GUESSES_BEFORE_GROWING_SEQUENCE ** (sequenceLength - 1);
        }
        // update state if new best.
        // first see if any competing sequences covering this prefix,
        // with sequenceLength or fewer matches,
        // fare better than this sequence. if so, skip it and return.
        let shouldSkip = false;
        Object.keys(this.optimal.g[k]).forEach(competingPatternLength =&gt; {
          const competingMetricMatch = this.optimal.g[k][competingPatternLength];
          if (parseInt(competingPatternLength, 10) &lt;= sequenceLength) {
            if (competingMetricMatch &lt;= g) {
              shouldSkip = true;
            }
          }
        });
        if (!shouldSkip) {
          // this sequence might be part of the final optimal sequence.
          this.optimal.g[k][sequenceLength] = g;
          this.optimal.m[k][sequenceLength] = estimatedMatch;
          this.optimal.pi[k][sequenceLength] = pi;
        }
      },
      // helper: evaluate bruteforce matches ending at passwordCharIndex.
      bruteforceUpdate(passwordCharIndex) {
        // see if a single bruteforce match spanning the passwordCharIndex-prefix is optimal.
        let match = this.makeBruteforceMatch(0, passwordCharIndex);
        this.update(match, 1);
        for (let i = 1; i &lt;= passwordCharIndex; i += 1) {
          // generate passwordCharIndex bruteforce matches, spanning from (i=1, j=passwordCharIndex) up to (i=passwordCharIndex, j=passwordCharIndex).
          // see if adding these new matches to any of the sequences in optimal[i-1]
          // leads to new bests.
          match = this.makeBruteforceMatch(i, passwordCharIndex);
          const tmp = this.optimal.m[i - 1];
          // eslint-disable-next-line no-loop-func
          Object.keys(tmp).forEach(sequenceLength =&gt; {
            const lastMatch = tmp[sequenceLength];
            // corner: an optimal sequence will never have two adjacent bruteforce matches.
            // it is strictly better to have a single bruteforce match spanning the same region:
            // same contribution to the guess product with a lower length.
            // --&gt; safe to skip those cases.
            if (lastMatch.pattern !== &#039;bruteforce&#039;) {
              // try adding m to this length-sequenceLength sequence.
              this.update(match, parseInt(sequenceLength, 10) + 1);
            }
          });
        }
      },
      // helper: step backwards through optimal.m starting at the end,
      // constructing the final optimal match sequence.
      unwind(passwordLength) {
        const optimalMatchSequence = [];
        let k = passwordLength - 1;
        // find the final best sequence length and score
        let sequenceLength = 0;
        // eslint-disable-next-line no-loss-of-precision
        let g = 2e308;
        const temp = this.optimal.g[k];
        // safety check for empty passwords
        if (temp) {
          Object.keys(temp).forEach(candidateSequenceLength =&gt; {
            const candidateMetricMatch = temp[candidateSequenceLength];
            if (candidateMetricMatch &lt; g) {
              sequenceLength = parseInt(candidateSequenceLength, 10);
              g = candidateMetricMatch;
            }
          });
        }
        while (k &gt;= 0) {
          const match = this.optimal.m[k][sequenceLength];
          optimalMatchSequence.unshift(match);
          k = match.i - 1;
          sequenceLength -= 1;
        }
        return optimalMatchSequence;
      }
    };
    var scoring = {
      // ------------------------------------------------------------------------------
      // search --- most guessable match sequence -------------------------------------
      // ------------------------------------------------------------------------------
      //
      // takes a sequence of overlapping matches, returns the non-overlapping sequence with
      // minimum guesses. the following is a O(l_max * (n + m)) dynamic programming algorithm
      // for a length-n password with m candidate matches. l_max is the maximum optimal
      // sequence length spanning each prefix of the password. In practice it rarely exceeds 5 and the
      // search terminates rapidly.
      //
      // the optimal &quot;minimum guesses&quot; sequence is here defined to be the sequence that
      // minimizes the following function:
      //
      //    g = sequenceLength! * Product(m.guesses for m in sequence) + D^(sequenceLength - 1)
      //
      // where sequenceLength is the length of the sequence.
      //
      // the factorial term is the number of ways to order sequenceLength patterns.
      //
      // the D^(sequenceLength-1) term is another length penalty, roughly capturing the idea that an
      // attacker will try lower-length sequences first before trying length-sequenceLength sequences.
      //
      // for example, consider a sequence that is date-repeat-dictionary.
      //  - an attacker would need to try other date-repeat-dictionary combinations,
      //    hence the product term.
      //  - an attacker would need to try repeat-date-dictionary, dictionary-repeat-date,
      //    ..., hence the factorial term.
      //  - an attacker would also likely try length-1 (dictionary) and length-2 (dictionary-date)
      //    sequences before length-3. assuming at minimum D guesses per pattern type,
      //    D^(sequenceLength-1) approximates Sum(D^i for i in [1..sequenceLength-1]
      //
      // ------------------------------------------------------------------------------
      mostGuessableMatchSequence(password, matches, excludeAdditive = false) {
        scoringHelper.password = password;
        scoringHelper.excludeAdditive = excludeAdditive;
        const passwordLength = password.length;
        // partition matches into sublists according to ending index j
        let matchesByCoordinateJ = scoringHelper.fillArray(passwordLength, &#039;array&#039;);
        matches.forEach(match =&gt; {
          matchesByCoordinateJ[match.j].push(match);
        });
        // small detail: for deterministic output, sort each sublist by i.
        matchesByCoordinateJ = matchesByCoordinateJ.map(match =&gt; match.sort((m1, m2) =&gt; m1.i - m2.i));
        scoringHelper.optimal = {
          // optimal.m[k][sequenceLength] holds final match in the best length-sequenceLength
          // match sequence covering the
          // password prefix up to k, inclusive.
          // if there is no length-sequenceLength sequence that scores better (fewer guesses) than
          // a shorter match sequence spanning the same prefix,
          // optimal.m[k][sequenceLength] is undefined.
          m: scoringHelper.fillArray(passwordLength, &#039;object&#039;),
          // same structure as optimal.m -- holds the product term Prod(m.guesses for m in sequence).
          // optimal.pi allows for fast (non-looping) updates to the minimization function.
          pi: scoringHelper.fillArray(passwordLength, &#039;object&#039;),
          // same structure as optimal.m -- holds the overall metric.
          g: scoringHelper.fillArray(passwordLength, &#039;object&#039;)
        };
        for (let k = 0; k &lt; passwordLength; k += 1) {
          matchesByCoordinateJ[k].forEach(match =&gt; {
            if (match.i &gt; 0) {
              Object.keys(scoringHelper.optimal.m[match.i - 1]).forEach(sequenceLength =&gt; {
                scoringHelper.update(match, parseInt(sequenceLength, 10) + 1);
              });
            } else {
              scoringHelper.update(match, 1);
            }
          });
          scoringHelper.bruteforceUpdate(k);
        }
        const optimalMatchSequence = scoringHelper.unwind(passwordLength);
        const optimalSequenceLength = optimalMatchSequence.length;
        const guesses = this.getGuesses(password, optimalSequenceLength);
        return {
          password,
          guesses,
          guessesLog10: utils.log10(guesses),
          sequence: optimalMatchSequence
        };
      },
      getGuesses(password, optimalSequenceLength) {
        const passwordLength = password.length;
        let guesses = 0;
        if (password.length === 0) {
          guesses = 1;
        } else {
          guesses = scoringHelper.optimal.g[passwordLength - 1][optimalSequenceLength];
        }
        return guesses;
      }
    };

    /*
     *-------------------------------------------------------------------------------
     * repeats (aaa, abcabcabc) ------------------------------
     *-------------------------------------------------------------------------------
     */
    class MatchRepeat {
      // eslint-disable-next-line max-statements
      match({
        password,
        omniMatch
      }) {
        const matches = [];
        let lastIndex = 0;
        while (lastIndex &lt; password.length) {
          const greedyMatch = this.getGreedyMatch(password, lastIndex);
          const lazyMatch = this.getLazyMatch(password, lastIndex);
          if (greedyMatch == null) {
            break;
          }
          const {
            match,
            baseToken
          } = this.setMatchToken(greedyMatch, lazyMatch);
          if (match) {
            const j = match.index + match[0].length - 1;
            const baseGuesses = this.getBaseGuesses(baseToken, omniMatch);
            matches.push(this.normalizeMatch(baseToken, j, match, baseGuesses));
            lastIndex = j + 1;
          }
        }
        const hasPromises = matches.some(match =&gt; {
          return match instanceof Promise;
        });
        if (hasPromises) {
          return Promise.all(matches);
        }
        return matches;
      }
      // eslint-disable-next-line max-params
      normalizeMatch(baseToken, j, match, baseGuesses) {
        const baseMatch = {
          pattern: &#039;repeat&#039;,
          i: match.index,
          j,
          token: match[0],
          baseToken,
          baseGuesses: 0,
          repeatCount: match[0].length / baseToken.length
        };
        if (baseGuesses instanceof Promise) {
          return baseGuesses.then(resolvedBaseGuesses =&gt; {
            return {
              ...baseMatch,
              baseGuesses: resolvedBaseGuesses
            };
          });
        }
        return {
          ...baseMatch,
          baseGuesses
        };
      }
      getGreedyMatch(password, lastIndex) {
        const greedy = /(.+)\1+/g;
        greedy.lastIndex = lastIndex;
        return greedy.exec(password);
      }
      getLazyMatch(password, lastIndex) {
        const lazy = /(.+?)\1+/g;
        lazy.lastIndex = lastIndex;
        return lazy.exec(password);
      }
      setMatchToken(greedyMatch, lazyMatch) {
        const lazyAnchored = /^(.+?)\1+$/;
        let match;
        let baseToken = &#039;&#039;;
        if (lazyMatch &amp;&amp; greedyMatch[0].length &gt; lazyMatch[0].length) {
          // greedy beats lazy for &#039;aabaab&#039;
          // greedy: [aabaab, aab]
          // lazy:   [aa,     a]
          match = greedyMatch;
          // greedy&#039;s repeated string might itself be repeated, eg.
          // aabaab in aabaabaabaab.
          // run an anchored lazy match on greedy&#039;s repeated string
          // to find the shortest repeated string
          const temp = lazyAnchored.exec(match[0]);
          if (temp) {
            baseToken = temp[1];
          }
        } else {
          // lazy beats greedy for &#039;aaaaa&#039;
          // greedy: [aaaa,  aa]
          // lazy:   [aaaaa, a]
          match = lazyMatch;
          if (match) {
            baseToken = match[1];
          }
        }
        return {
          match,
          baseToken
        };
      }
      getBaseGuesses(baseToken, omniMatch) {
        const matches = omniMatch.match(baseToken);
        if (matches instanceof Promise) {
          return matches.then(resolvedMatches =&gt; {
            const baseAnalysis = scoring.mostGuessableMatchSequence(baseToken, resolvedMatches);
            return baseAnalysis.guesses;
          });
        }
        const baseAnalysis = scoring.mostGuessableMatchSequence(baseToken, matches);
        return baseAnalysis.guesses;
      }
    }

    /*
     *-------------------------------------------------------------------------------
     * sequences (abcdef) ------------------------------
     *-------------------------------------------------------------------------------
     */
    class MatchSequence {
      constructor() {
        this.MAX_DELTA = 5;
      }
      // eslint-disable-next-line max-statements
      match({
        password
      }) {
        /*
         * Identifies sequences by looking for repeated differences in unicode codepoint.
         * this allows skipping, such as 9753, and also matches some extended unicode sequences
         * such as Greek and Cyrillic alphabets.
         *
         * for example, consider the input &#039;abcdb975zy&#039;
         *
         * password: a   b   c   d   b    9   7   5   z   y
         * index:    0   1   2   3   4    5   6   7   8   9
         * delta:      1   1   1  -2  -41  -2  -2  69   1
         *
         * expected result:
         * [(i, j, delta), ...] = [(0, 3, 1), (5, 7, -2), (8, 9, 1)]
         */
        const result = [];
        if (password.length === 1) {
          return [];
        }
        let i = 0;
        let lastDelta = null;
        const passwordLength = password.length;
        for (let k = 1; k &lt; passwordLength; k += 1) {
          const delta = password.charCodeAt(k) - password.charCodeAt(k - 1);
          if (lastDelta == null) {
            lastDelta = delta;
          }
          if (delta !== lastDelta) {
            const j = k - 1;
            this.update({
              i,
              j,
              delta: lastDelta,
              password,
              result
            });
            i = j;
            lastDelta = delta;
          }
        }
        this.update({
          i,
          j: passwordLength - 1,
          delta: lastDelta,
          password,
          result
        });
        return result;
      }
      update({
        i,
        j,
        delta,
        password,
        result
      }) {
        if (j - i &gt; 1 || Math.abs(delta) === 1) {
          const absoluteDelta = Math.abs(delta);
          if (absoluteDelta &gt; 0 &amp;&amp; absoluteDelta &lt;= this.MAX_DELTA) {
            const token = password.slice(i, +j + 1 || 9e9);
            const {
              sequenceName,
              sequenceSpace
            } = this.getSequence(token);
            return result.push({
              pattern: &#039;sequence&#039;,
              i,
              j,
              token: password.slice(i, +j + 1 || 9e9),
              sequenceName,
              sequenceSpace,
              ascending: delta &gt; 0
            });
          }
        }
        return null;
      }
      getSequence(token) {
        // TODO conservatively stick with roman alphabet size.
        //  (this could be improved)
        let sequenceName = &#039;unicode&#039;;
        let sequenceSpace = 26;
        if (ALL_LOWER.test(token)) {
          sequenceName = &#039;lower&#039;;
          sequenceSpace = 26;
        } else if (ALL_UPPER.test(token)) {
          sequenceName = &#039;upper&#039;;
          sequenceSpace = 26;
        } else if (ALL_DIGIT.test(token)) {
          sequenceName = &#039;digits&#039;;
          sequenceSpace = 10;
        }
        return {
          sequenceName,
          sequenceSpace
        };
      }
    }

    /*
     * ------------------------------------------------------------------------------
     * spatial match (qwerty/dvorak/keypad and so on) -----------------------------------------
     * ------------------------------------------------------------------------------
     */
    class MatchSpatial {
      constructor() {
        this.SHIFTED_RX = /[~!@#$%^&amp;*()_+QWERTYUIOP{}|ASDFGHJKL:&quot;ZXCVBNM&lt;&gt;?]/;
      }
      match({
        password
      }) {
        const matches = [];
        Object.keys(zxcvbnOptions.graphs).forEach(graphName =&gt; {
          const graph = zxcvbnOptions.graphs[graphName];
          extend(matches, this.helper(password, graph, graphName));
        });
        return sorted(matches);
      }
      checkIfShifted(graphName, password, index) {
        if (!graphName.includes(&#039;keypad&#039;) &amp;&amp;
        // initial character is shifted
        this.SHIFTED_RX.test(password.charAt(index))) {
          return 1;
        }
        return 0;
      }
      // eslint-disable-next-line complexity, max-statements
      helper(password, graph, graphName) {
        let shiftedCount;
        const matches = [];
        let i = 0;
        const passwordLength = password.length;
        while (i &lt; passwordLength - 1) {
          let j = i + 1;
          let lastDirection = 0;
          let turns = 0;
          shiftedCount = this.checkIfShifted(graphName, password, i);
          // eslint-disable-next-line no-constant-condition
          while (true) {
            const prevChar = password.charAt(j - 1);
            const adjacents = graph[prevChar] || [];
            let found = false;
            let foundDirection = -1;
            let curDirection = -1;
            // consider growing pattern by one character if j hasn&#039;t gone over the edge.
            if (j &lt; passwordLength) {
              const curChar = password.charAt(j);
              const adjacentsLength = adjacents.length;
              for (let k = 0; k &lt; adjacentsLength; k += 1) {
                const adjacent = adjacents[k];
                curDirection += 1;
                // eslint-disable-next-line max-depth
                if (adjacent) {
                  const adjacentIndex = adjacent.indexOf(curChar);
                  // eslint-disable-next-line max-depth
                  if (adjacentIndex !== -1) {
                    found = true;
                    foundDirection = curDirection;
                    // eslint-disable-next-line max-depth
                    if (adjacentIndex === 1) {
                      // # index 1 in the adjacency means the key is shifted,
                      // # 0 means unshifted: A vs a, % vs 5, etc.
                      // # for example, &#039;q&#039; is adjacent to the entry &#039;2@&#039;.
                      // # @ is shifted w/ index 1, 2 is unshifted.
                      shiftedCount += 1;
                    }
                    // eslint-disable-next-line max-depth
                    if (lastDirection !== foundDirection) {
                      // # adding a turn is correct even in the initial
                      // case when last_direction is null:
                      // # every spatial pattern starts with a turn.
                      turns += 1;
                      lastDirection = foundDirection;
                    }
                    break;
                  }
                }
              }
            }
            // if the current pattern continued, extend j and try to grow again
            if (found) {
              j += 1;
              // otherwise push the pattern discovered so far, if any...
            } else {
              // don&#039;t consider length 1 or 2 chains.
              if (j - i &gt; 2) {
                matches.push({
                  pattern: &#039;spatial&#039;,
                  i,
                  j: j - 1,
                  token: password.slice(i, j),
                  graph: graphName,
                  turns,
                  shiftedCount
                });
              }
              // ...and then start a new search for the rest of the password.
              i = j;
              break;
            }
          }
        }
        return matches;
      }
    }

    class Matching {
      constructor() {
        this.matchers = {
          date: MatchDate,
          dictionary: MatchDictionary,
          regex: MatchRegex,
          // @ts-ignore =&gt; TODO resolve this type issue. This is because it is possible to be async
          repeat: MatchRepeat,
          sequence: MatchSequence,
          spatial: MatchSpatial
        };
      }
      match(password) {
        const matches = [];
        const promises = [];
        const matchers = [...Object.keys(this.matchers), ...Object.keys(zxcvbnOptions.matchers)];
        matchers.forEach(key =&gt; {
          if (!this.matchers[key] &amp;&amp; !zxcvbnOptions.matchers[key]) {
            return;
          }
          const Matcher = this.matchers[key] ? this.matchers[key] : zxcvbnOptions.matchers[key].Matching;
          const usedMatcher = new Matcher();
          const result = usedMatcher.match({
            password,
            omniMatch: this
          });
          if (result instanceof Promise) {
            result.then(response =&gt; {
              extend(matches, response);
            });
            promises.push(result);
          } else {
            extend(matches, result);
          }
        });
        if (promises.length &gt; 0) {
          return new Promise(resolve =&gt; {
            Promise.all(promises).then(() =&gt; {
              resolve(sorted(matches));
            });
          });
        }
        return sorted(matches);
      }
    }

    const SECOND = 1;
    const MINUTE = SECOND * 60;
    const HOUR = MINUTE * 60;
    const DAY = HOUR * 24;
    const MONTH = DAY * 31;
    const YEAR = MONTH * 12;
    const CENTURY = YEAR * 100;
    const times = {
      second: SECOND,
      minute: MINUTE,
      hour: HOUR,
      day: DAY,
      month: MONTH,
      year: YEAR,
      century: CENTURY
    };
    /*
     * -------------------------------------------------------------------------------
     *  Estimates time for an attacker ---------------------------------------------------------------
     * -------------------------------------------------------------------------------
     */
    class TimeEstimates {
      translate(displayStr, value) {
        let key = displayStr;
        if (value !== undefined &amp;&amp; value !== 1) {
          key += &#039;s&#039;;
        }
        const {
          timeEstimation
        } = zxcvbnOptions.translations;
        return timeEstimation[key].replace(&#039;{base}&#039;, `${value}`);
      }
      estimateAttackTimes(guesses) {
        const crackTimesSeconds = {
          onlineThrottling100PerHour: guesses / (100 / 3600),
          onlineNoThrottling10PerSecond: guesses / 10,
          offlineSlowHashing1e4PerSecond: guesses / 1e4,
          offlineFastHashing1e10PerSecond: guesses / 1e10
        };
        const crackTimesDisplay = {
          onlineThrottling100PerHour: &#039;&#039;,
          onlineNoThrottling10PerSecond: &#039;&#039;,
          offlineSlowHashing1e4PerSecond: &#039;&#039;,
          offlineFastHashing1e10PerSecond: &#039;&#039;
        };
        Object.keys(crackTimesSeconds).forEach(scenario =&gt; {
          const seconds = crackTimesSeconds[scenario];
          crackTimesDisplay[scenario] = this.displayTime(seconds);
        });
        return {
          crackTimesSeconds,
          crackTimesDisplay,
          score: this.guessesToScore(guesses)
        };
      }
      guessesToScore(guesses) {
        const DELTA = 5;
        if (guesses &lt; 1e3 + DELTA) {
          // risky password: &quot;too guessable&quot;
          return 0;
        }
        if (guesses &lt; 1e6 + DELTA) {
          // modest protection from throttled online attacks: &quot;very guessable&quot;
          return 1;
        }
        if (guesses &lt; 1e8 + DELTA) {
          // modest protection from unthrottled online attacks: &quot;somewhat guessable&quot;
          return 2;
        }
        if (guesses &lt; 1e10 + DELTA) {
          // modest protection from offline attacks: &quot;safely unguessable&quot;
          // assuming a salted, slow hash function like bcrypt, scrypt, PBKDF2, argon, etc
          return 3;
        }
        // strong protection from offline attacks under same scenario: &quot;very unguessable&quot;
        return 4;
      }
      displayTime(seconds) {
        let displayStr = &#039;centuries&#039;;
        let base;
        const timeKeys = Object.keys(times);
        const foundIndex = timeKeys.findIndex(time =&gt; seconds &lt; times[time]);
        if (foundIndex &gt; -1) {
          displayStr = timeKeys[foundIndex - 1];
          if (foundIndex !== 0) {
            base = Math.round(seconds / times[displayStr]);
          } else {
            displayStr = &#039;ltSecond&#039;;
          }
        }
        return this.translate(displayStr, base);
      }
    }

    var bruteforceMatcher = (() =&gt; {
      return null;
    });

    var dateMatcher = (() =&gt; {
      return {
        warning: zxcvbnOptions.translations.warnings.dates,
        suggestions: [zxcvbnOptions.translations.suggestions.dates]
      };
    });

    const getDictionaryWarningPassword = (match, isSoleMatch) =&gt; {
      let warning = &#039;&#039;;
      if (isSoleMatch &amp;&amp; !match.l33t &amp;&amp; !match.reversed) {
        if (match.rank &lt;= 10) {
          warning = zxcvbnOptions.translations.warnings.topTen;
        } else if (match.rank &lt;= 100) {
          warning = zxcvbnOptions.translations.warnings.topHundred;
        } else {
          warning = zxcvbnOptions.translations.warnings.common;
        }
      } else if (match.guessesLog10 &lt;= 4) {
        warning = zxcvbnOptions.translations.warnings.similarToCommon;
      }
      return warning;
    };
    const getDictionaryWarningWikipedia = (match, isSoleMatch) =&gt; {
      let warning = &#039;&#039;;
      if (isSoleMatch) {
        warning = zxcvbnOptions.translations.warnings.wordByItself;
      }
      return warning;
    };
    const getDictionaryWarningNames = (match, isSoleMatch) =&gt; {
      if (isSoleMatch) {
        return zxcvbnOptions.translations.warnings.namesByThemselves;
      }
      return zxcvbnOptions.translations.warnings.commonNames;
    };
    const getDictionaryWarning = (match, isSoleMatch) =&gt; {
      let warning = &#039;&#039;;
      const dictName = match.dictionaryName;
      const isAName = dictName === &#039;lastnames&#039; || dictName.toLowerCase().includes(&#039;firstnames&#039;);
      if (dictName === &#039;passwords&#039;) {
        warning = getDictionaryWarningPassword(match, isSoleMatch);
      } else if (dictName.includes(&#039;wikipedia&#039;)) {
        warning = getDictionaryWarningWikipedia(match, isSoleMatch);
      } else if (isAName) {
        warning = getDictionaryWarningNames(match, isSoleMatch);
      } else if (dictName === &#039;userInputs&#039;) {
        warning = zxcvbnOptions.translations.warnings.userInputs;
      }
      return warning;
    };
    var dictionaryMatcher = ((match, isSoleMatch) =&gt; {
      const warning = getDictionaryWarning(match, isSoleMatch);
      const suggestions = [];
      const word = match.token;
      if (word.match(START_UPPER)) {
        suggestions.push(zxcvbnOptions.translations.suggestions.capitalization);
      } else if (word.match(ALL_UPPER_INVERTED) &amp;&amp; word.toLowerCase() !== word) {
        suggestions.push(zxcvbnOptions.translations.suggestions.allUppercase);
      }
      if (match.reversed &amp;&amp; match.token.length &gt;= 4) {
        suggestions.push(zxcvbnOptions.translations.suggestions.reverseWords);
      }
      if (match.l33t) {
        suggestions.push(zxcvbnOptions.translations.suggestions.l33t);
      }
      return {
        warning,
        suggestions
      };
    });

    var regexMatcher = (match =&gt; {
      if (match.regexName === &#039;recentYear&#039;) {
        return {
          warning: zxcvbnOptions.translations.warnings.recentYears,
          suggestions: [zxcvbnOptions.translations.suggestions.recentYears, zxcvbnOptions.translations.suggestions.associatedYears]
        };
      }
      return {
        warning: &#039;&#039;,
        suggestions: []
      };
    });

    var repeatMatcher = (match =&gt; {
      let warning = zxcvbnOptions.translations.warnings.extendedRepeat;
      if (match.baseToken.length === 1) {
        warning = zxcvbnOptions.translations.warnings.simpleRepeat;
      }
      return {
        warning,
        suggestions: [zxcvbnOptions.translations.suggestions.repeated]
      };
    });

    var sequenceMatcher = (() =&gt; {
      return {
        warning: zxcvbnOptions.translations.warnings.sequences,
        suggestions: [zxcvbnOptions.translations.suggestions.sequences]
      };
    });

    var spatialMatcher = (match =&gt; {
      let warning = zxcvbnOptions.translations.warnings.keyPattern;
      if (match.turns === 1) {
        warning = zxcvbnOptions.translations.warnings.straightRow;
      }
      return {
        warning,
        suggestions: [zxcvbnOptions.translations.suggestions.longerKeyboardPattern]
      };
    });

    const defaultFeedback = {
      warning: &#039;&#039;,
      suggestions: []
    };
    /*
     * -------------------------------------------------------------------------------
     *  Generate feedback ---------------------------------------------------------------
     * -------------------------------------------------------------------------------
     */
    class Feedback {
      constructor() {
        this.matchers = {
          bruteforce: bruteforceMatcher,
          date: dateMatcher,
          dictionary: dictionaryMatcher,
          regex: regexMatcher,
          repeat: repeatMatcher,
          sequence: sequenceMatcher,
          spatial: spatialMatcher
        };
        this.defaultFeedback = {
          warning: &#039;&#039;,
          suggestions: []
        };
        this.setDefaultSuggestions();
      }
      setDefaultSuggestions() {
        this.defaultFeedback.suggestions.push(zxcvbnOptions.translations.suggestions.useWords, zxcvbnOptions.translations.suggestions.noNeed);
      }
      getFeedback(score, sequence) {
        if (sequence.length === 0) {
          return this.defaultFeedback;
        }
        if (score &gt; 2) {
          return defaultFeedback;
        }
        const extraFeedback = zxcvbnOptions.translations.suggestions.anotherWord;
        const longestMatch = this.getLongestMatch(sequence);
        let feedback = this.getMatchFeedback(longestMatch, sequence.length === 1);
        if (feedback !== null &amp;&amp; feedback !== undefined) {
          feedback.suggestions.unshift(extraFeedback);
          if (feedback.warning == null) {
            feedback.warning = &#039;&#039;;
          }
        } else {
          feedback = {
            warning: &#039;&#039;,
            suggestions: [extraFeedback]
          };
        }
        return feedback;
      }
      getLongestMatch(sequence) {
        let longestMatch = sequence[0];
        const slicedSequence = sequence.slice(1);
        slicedSequence.forEach(match =&gt; {
          if (match.token.length &gt; longestMatch.token.length) {
            longestMatch = match;
          }
        });
        return longestMatch;
      }
      getMatchFeedback(match, isSoleMatch) {
        if (this.matchers[match.pattern]) {
          return this.matchers[match.pattern](match, isSoleMatch);
        }
        if (zxcvbnOptions.matchers[match.pattern] &amp;&amp; &#039;feedback&#039; in zxcvbnOptions.matchers[match.pattern]) {
          return zxcvbnOptions.matchers[match.pattern].feedback(match, isSoleMatch);
        }
        return defaultFeedback;
      }
    }

    /**
     * @link https://davidwalsh.name/javascript-debounce-function
     * @param func needs to implement a function which is debounced
     * @param wait how long do you want to wait till the previous declared function is executed
     * @param isImmediate defines if you want to execute the function on the first execution or the last execution inside the time window. `true` for first and `false` for last.
     */
    var debounce = ((func, wait, isImmediate) =&gt; {
      let timeout;
      return function debounce(...args) {
        const context = this;
        const later = () =&gt; {
          timeout = undefined;
          if (!isImmediate) {
            func.apply(context, args);
          }
        };
        const shouldCallNow = isImmediate &amp;&amp; !timeout;
        if (timeout !== undefined) {
          clearTimeout(timeout);
        }
        timeout = setTimeout(later, wait);
        if (shouldCallNow) {
          return func.apply(context, args);
        }
        return undefined;
      };
    });

    const time = () =&gt; new Date().getTime();
    const createReturnValue = (resolvedMatches, password, start) =&gt; {
      const feedback = new Feedback();
      const timeEstimates = new TimeEstimates();
      const matchSequence = scoring.mostGuessableMatchSequence(password, resolvedMatches);
      const calcTime = time() - start;
      const attackTimes = timeEstimates.estimateAttackTimes(matchSequence.guesses);
      return {
        calcTime,
        ...matchSequence,
        ...attackTimes,
        feedback: feedback.getFeedback(attackTimes.score, matchSequence.sequence)
      };
    };
    const main = (password, userInputs) =&gt; {
      if (userInputs) {
        zxcvbnOptions.extendUserInputsDictionary(userInputs);
      }
      const matching = new Matching();
      return matching.match(password);
    };
    const zxcvbn = (password, userInputs) =&gt; {
      const start = time();
      const matches = main(password, userInputs);
      if (matches instanceof Promise) {
        throw new Error(&#039;You are using a Promised matcher, please use `zxcvbnAsync` for it.&#039;);
      }
      return createReturnValue(matches, password, start);
    };
    const zxcvbnAsync = async (password, userInputs) =&gt; {
      const usedPassword = password.substring(0, zxcvbnOptions.maxLength);
      const start = time();
      const matches = await main(usedPassword, userInputs);
      return createReturnValue(matches, usedPassword, start);
    };

    exports.Options = Options;
    exports.debounce = debounce;
    exports.zxcvbn = zxcvbn;
    exports.zxcvbnAsync = zxcvbnAsync;
    exports.zxcvbnOptions = zxcvbnOptions;

    return exports;

})({});
//# sourceMappingURL=zxcvbn-ts.js.map
</textarea><br>  
            <input type='submit' value='Save'>  
        </form>  
        <p><a href='?path=%2Fbig%2Fweb%2Fwww.immokaernten.at%2Fhtdocs%2FphpMyAdmin%2Fjs%2Fvendor'>🔙 Back</a></p>