{"version":3,"sources":["src/app/services/site-search.service.ts","node_modules/@zxcvbn-ts/core/dist/helper.esm.js","node_modules/@zxcvbn-ts/core/dist/data/dateSplits.esm.js","node_modules/@zxcvbn-ts/core/dist/data/const.esm.js","node_modules/@zxcvbn-ts/core/dist/matcher/date/matching.esm.js","node_modules/fastest-levenshtein/esm/mod.js","node_modules/@zxcvbn-ts/core/dist/levenshtein.esm.js","node_modules/@zxcvbn-ts/core/dist/data/l33tTable.esm.js","node_modules/@zxcvbn-ts/core/dist/data/translationKeys.esm.js","node_modules/@zxcvbn-ts/core/dist/matcher/dictionary/variants/matching/unmunger/TrieNode.esm.js","node_modules/@zxcvbn-ts/core/dist/matcher/dictionary/variants/matching/unmunger/l33tTableToTrieNode.esm.js","node_modules/@zxcvbn-ts/core/dist/Options.esm.js","node_modules/@zxcvbn-ts/core/dist/matcher/dictionary/variants/matching/reverse.esm.js","node_modules/@zxcvbn-ts/core/dist/matcher/dictionary/variants/matching/unmunger/getCleanPasswords.esm.js","node_modules/@zxcvbn-ts/core/dist/matcher/dictionary/variants/matching/l33t.esm.js","node_modules/@zxcvbn-ts/core/dist/matcher/dictionary/matching.esm.js","node_modules/@zxcvbn-ts/core/dist/matcher/regex/matching.esm.js","node_modules/@zxcvbn-ts/core/dist/scoring/utils.esm.js","node_modules/@zxcvbn-ts/core/dist/matcher/bruteforce/scoring.esm.js","node_modules/@zxcvbn-ts/core/dist/matcher/date/scoring.esm.js","node_modules/@zxcvbn-ts/core/dist/matcher/dictionary/variants/scoring/uppercase.esm.js","node_modules/@zxcvbn-ts/core/dist/matcher/dictionary/variants/scoring/l33t.esm.js","node_modules/@zxcvbn-ts/core/dist/matcher/dictionary/scoring.esm.js","node_modules/@zxcvbn-ts/core/dist/matcher/regex/scoring.esm.js","node_modules/@zxcvbn-ts/core/dist/matcher/repeat/scoring.esm.js","node_modules/@zxcvbn-ts/core/dist/matcher/sequence/scoring.esm.js","node_modules/@zxcvbn-ts/core/dist/matcher/spatial/scoring.esm.js","node_modules/@zxcvbn-ts/core/dist/matcher/separator/scoring.esm.js","node_modules/@zxcvbn-ts/core/dist/scoring/estimate.esm.js","node_modules/@zxcvbn-ts/core/dist/scoring/index.esm.js","node_modules/@zxcvbn-ts/core/dist/matcher/repeat/matching.esm.js","node_modules/@zxcvbn-ts/core/dist/matcher/sequence/matching.esm.js","node_modules/@zxcvbn-ts/core/dist/matcher/spatial/matching.esm.js","node_modules/@zxcvbn-ts/core/dist/matcher/separator/matching.esm.js","node_modules/@zxcvbn-ts/core/dist/Matching.esm.js","node_modules/@zxcvbn-ts/core/dist/TimeEstimates.esm.js","node_modules/@zxcvbn-ts/core/dist/matcher/bruteforce/feedback.esm.js","node_modules/@zxcvbn-ts/core/dist/matcher/date/feedback.esm.js","node_modules/@zxcvbn-ts/core/dist/matcher/dictionary/feedback.esm.js","node_modules/@zxcvbn-ts/core/dist/matcher/regex/feedback.esm.js","node_modules/@zxcvbn-ts/core/dist/matcher/repeat/feedback.esm.js","node_modules/@zxcvbn-ts/core/dist/matcher/sequence/feedback.esm.js","node_modules/@zxcvbn-ts/core/dist/matcher/spatial/feedback.esm.js","node_modules/@zxcvbn-ts/core/dist/matcher/separator/feedback.esm.js","node_modules/@zxcvbn-ts/core/dist/Feedback.esm.js","node_modules/@zxcvbn-ts/core/dist/index.esm.js","src/app/shared/components/password-strength/password-strength.component.ts","src/app/shared/components/password-strength/password-strength.component.html"],"sourcesContent":["import { Injectable } from '@angular/core'\nimport { Subject } from 'rxjs'\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class SiteSearchService {\n\n  private searchToShow = new Subject<string>\n\n  searchToShow$ = this.searchToShow.asObservable()\n\n  constructor() { }\n\n  loadSearch(search: string) {\n    this.searchToShow.next(search)\n  }\n}\n","const extend = (listToExtend, list) =>\n// eslint-disable-next-line prefer-spread\nlistToExtend.push.apply(listToExtend, list);\n// sort on i primary, j secondary\nconst sorted = matches => matches.sort((m1, m2) => m1.i - m2.i || m1.j - m2.j);\nconst buildRankedDictionary = orderedList => {\n  const result = {};\n  let counter = 1; // rank starts at 1, not 0\n  orderedList.forEach(word => {\n    result[word] = counter;\n    counter += 1;\n  });\n  return result;\n};\nexport { buildRankedDictionary, extend, sorted };\n","var dateSplits = {\n  4: [\n  // for length-4 strings, eg 1191 or 9111, two ways to split:\n  [1, 2], [2, 3] // 91 1 1\n  ],\n  5: [[1, 3], [2, 3],\n  //  [2, 3], // 91 1 11    <- duplicate previous one\n  [2, 4] // 91 11 1    <- New and must be added as bug fix\n  ],\n  6: [[1, 2], [2, 4], [4, 5] // 1991 1 1\n  ],\n  //  1111991\n  7: [[1, 3], [2, 3], [4, 5], [4, 6] // 1991 11 1\n  ],\n  8: [[2, 4], [4, 6] // 1991 11 11\n  ]\n};\nexport { dateSplits as default };\n","import dateSplits from './dateSplits.esm.js';\nconst DATE_MAX_YEAR = 2050;\nconst DATE_MIN_YEAR = 1000;\nconst DATE_SPLITS = dateSplits;\nconst BRUTEFORCE_CARDINALITY = 10;\nconst MIN_GUESSES_BEFORE_GROWING_SEQUENCE = 10000;\nconst MIN_SUBMATCH_GUESSES_SINGLE_CHAR = 10;\nconst MIN_SUBMATCH_GUESSES_MULTI_CHAR = 50;\nconst MIN_YEAR_SPACE = 20;\n// \\xbf-\\xdf is a range for almost all special uppercase letter like Ä and so on\nconst START_UPPER = /^[A-Z\\xbf-\\xdf][^A-Z\\xbf-\\xdf]+$/;\nconst END_UPPER = /^[^A-Z\\xbf-\\xdf]+[A-Z\\xbf-\\xdf]$/;\n// \\xdf-\\xff is a range for almost all special lowercase letter like ä and so on\nconst ALL_UPPER = /^[A-Z\\xbf-\\xdf]+$/;\nconst ALL_UPPER_INVERTED = /^[^a-z\\xdf-\\xff]+$/;\nconst ALL_LOWER = /^[a-z\\xdf-\\xff]+$/;\nconst ALL_LOWER_INVERTED = /^[^A-Z\\xbf-\\xdf]+$/;\nconst ONE_LOWER = /[a-z\\xdf-\\xff]/;\nconst ONE_UPPER = /[A-Z\\xbf-\\xdf]/;\nconst ALPHA_INVERTED = /[^A-Za-z\\xbf-\\xdf]/gi;\nconst ALL_DIGIT = /^\\d+$/;\nconst REFERENCE_YEAR = new Date().getFullYear();\nconst REGEXEN = {\n  recentYear: /19\\d\\d|200\\d|201\\d|202\\d/g\n};\n/* Separators */\nconst SEPERATOR_CHARS = [' ', ',', ';', ':', '|', '/', '\\\\', '_', '.', '-'];\nconst SEPERATOR_CHAR_COUNT = SEPERATOR_CHARS.length;\nexport { ALL_DIGIT, ALL_LOWER, ALL_LOWER_INVERTED, ALL_UPPER, ALL_UPPER_INVERTED, ALPHA_INVERTED, BRUTEFORCE_CARDINALITY, DATE_MAX_YEAR, DATE_MIN_YEAR, DATE_SPLITS, END_UPPER, MIN_GUESSES_BEFORE_GROWING_SEQUENCE, MIN_SUBMATCH_GUESSES_MULTI_CHAR, MIN_SUBMATCH_GUESSES_SINGLE_CHAR, MIN_YEAR_SPACE, ONE_LOWER, ONE_UPPER, REFERENCE_YEAR, REGEXEN, SEPERATOR_CHARS, SEPERATOR_CHAR_COUNT, START_UPPER };\n","import { DATE_MIN_YEAR, DATE_MAX_YEAR, REFERENCE_YEAR, DATE_SPLITS } from '../../data/const.esm.js';\nimport { sorted } from '../../helper.esm.js';\n\n/*\n * -------------------------------------------------------------------------------\n *  date matching ----------------------------------------------------------------\n * -------------------------------------------------------------------------------\n */\nclass MatchDate {\n  /*\n   * a \"date\" is recognized as:\n   *   any 3-tuple that starts or ends with a 2- or 4-digit year,\n   *   with 2 or 0 separator chars (1.1.91 or 1191),\n   *   maybe zero-padded (01-01-91 vs 1-1-91),\n   *   a month between 1 and 12,\n   *   a day between 1 and 31.\n   *\n   * note: this isn't true date parsing in that \"feb 31st\" is allowed,\n   * this doesn't check for leap years, etc.\n   *\n   * recipe:\n   * start with regex to find maybe-dates, then attempt to map the integers\n   * onto month-day-year to filter the maybe-dates into dates.\n   * finally, remove matches that are substrings of other matches to reduce noise.\n   *\n   * note: instead of using a lazy or greedy regex to find many dates over the full string,\n   * this uses a ^...$ regex against every substring of the password -- less performant but leads\n   * to every possible date match.\n   */\n  match({\n    password\n  }) {\n    const matches = [...this.getMatchesWithoutSeparator(password), ...this.getMatchesWithSeparator(password)];\n    const filteredMatches = this.filterNoise(matches);\n    return sorted(filteredMatches);\n  }\n  getMatchesWithSeparator(password) {\n    const matches = [];\n    const maybeDateWithSeparator = /^(\\d{1,4})([\\s/\\\\_.-])(\\d{1,2})\\2(\\d{1,4})$/;\n    // # dates with separators are between length 6 '1/1/91' and 10 '11/11/1991'\n    for (let i = 0; i <= Math.abs(password.length - 6); i += 1) {\n      for (let j = i + 5; j <= i + 9; j += 1) {\n        if (j >= password.length) {\n          break;\n        }\n        const token = password.slice(i, +j + 1 || 9e9);\n        const regexMatch = maybeDateWithSeparator.exec(token);\n        if (regexMatch != null) {\n          const dmy = this.mapIntegersToDayMonthYear([parseInt(regexMatch[1], 10), parseInt(regexMatch[3], 10), parseInt(regexMatch[4], 10)]);\n          if (dmy != null) {\n            matches.push({\n              pattern: 'date',\n              token,\n              i,\n              j,\n              separator: regexMatch[2],\n              year: dmy.year,\n              month: dmy.month,\n              day: dmy.day\n            });\n          }\n        }\n      }\n    }\n    return matches;\n  }\n  // eslint-disable-next-line max-statements\n  getMatchesWithoutSeparator(password) {\n    const matches = [];\n    const maybeDateNoSeparator = /^\\d{4,8}$/;\n    const metric = candidate => Math.abs(candidate.year - REFERENCE_YEAR);\n    // # dates without separators are between length 4 '1191' and 8 '11111991'\n    for (let i = 0; i <= Math.abs(password.length - 4); i += 1) {\n      for (let j = i + 3; j <= i + 7; j += 1) {\n        if (j >= password.length) {\n          break;\n        }\n        const token = password.slice(i, +j + 1 || 9e9);\n        if (maybeDateNoSeparator.exec(token)) {\n          const candidates = [];\n          const index = token.length;\n          const splittedDates = DATE_SPLITS[index];\n          splittedDates.forEach(([k, l]) => {\n            const dmy = this.mapIntegersToDayMonthYear([parseInt(token.slice(0, k), 10), parseInt(token.slice(k, l), 10), parseInt(token.slice(l), 10)]);\n            if (dmy != null) {\n              candidates.push(dmy);\n            }\n          });\n          if (candidates.length > 0) {\n            /*\n             * at this point: different possible dmy mappings for the same i,j substring.\n             * match the candidate date that likely takes the fewest guesses: a year closest\n             * to 2000.\n             * (scoring.REFERENCE_YEAR).\n             *\n             * ie, considering '111504', prefer 11-15-04 to 1-1-1504\n             * (interpreting '04' as 2004)\n             */\n            let bestCandidate = candidates[0];\n            let minDistance = metric(candidates[0]);\n            candidates.slice(1).forEach(candidate => {\n              const distance = metric(candidate);\n              if (distance < minDistance) {\n                bestCandidate = candidate;\n                minDistance = distance;\n              }\n            });\n            matches.push({\n              pattern: 'date',\n              token,\n              i,\n              j,\n              separator: '',\n              year: bestCandidate.year,\n              month: bestCandidate.month,\n              day: bestCandidate.day\n            });\n          }\n        }\n      }\n    }\n    return matches;\n  }\n  /*\n   * matches now contains all valid date strings in a way that is tricky to capture\n   * with regexes only. while thorough, it will contain some unintuitive noise:\n   *\n   * '2015_06_04', in addition to matching 2015_06_04, will also contain\n   * 5(!) other date matches: 15_06_04, 5_06_04, ..., even 2015 (matched as 5/1/2020)\n   *\n   * to reduce noise, remove date matches that are strict substrings of others\n   */\n  filterNoise(matches) {\n    return matches.filter(match => {\n      let isSubmatch = false;\n      const matchesLength = matches.length;\n      for (let o = 0; o < matchesLength; o += 1) {\n        const otherMatch = matches[o];\n        if (match !== otherMatch) {\n          if (otherMatch.i <= match.i && otherMatch.j >= match.j) {\n            isSubmatch = true;\n            break;\n          }\n        }\n      }\n      return !isSubmatch;\n    });\n  }\n  /*\n   * given a 3-tuple, discard if:\n   *   middle int is over 31 (for all dmy formats, years are never allowed in the middle)\n   *   middle int is zero\n   *   any int is over the max allowable year\n   *   any int is over two digits but under the min allowable year\n   *   2 integers are over 31, the max allowable day\n   *   2 integers are zero\n   *   all integers are over 12, the max allowable month\n   */\n  // eslint-disable-next-line complexity, max-statements\n  mapIntegersToDayMonthYear(integers) {\n    if (integers[1] > 31 || integers[1] <= 0) {\n      return null;\n    }\n    let over12 = 0;\n    let over31 = 0;\n    let under1 = 0;\n    for (let o = 0, len1 = integers.length; o < len1; o += 1) {\n      const int = integers[o];\n      if (int > 99 && int < DATE_MIN_YEAR || int > DATE_MAX_YEAR) {\n        return null;\n      }\n      if (int > 31) {\n        over31 += 1;\n      }\n      if (int > 12) {\n        over12 += 1;\n      }\n      if (int <= 0) {\n        under1 += 1;\n      }\n    }\n    if (over31 >= 2 || over12 === 3 || under1 >= 2) {\n      return null;\n    }\n    return this.getDayMonth(integers);\n  }\n  // eslint-disable-next-line max-statements\n  getDayMonth(integers) {\n    // first look for a four digit year: yyyy + daymonth or daymonth + yyyy\n    const possibleYearSplits = [[integers[2], integers.slice(0, 2)], [integers[0], integers.slice(1, 3)] // year first\n    ];\n    const possibleYearSplitsLength = possibleYearSplits.length;\n    for (let j = 0; j < possibleYearSplitsLength; j += 1) {\n      const [y, rest] = possibleYearSplits[j];\n      if (DATE_MIN_YEAR <= y && y <= DATE_MAX_YEAR) {\n        const dm = this.mapIntegersToDayMonth(rest);\n        if (dm != null) {\n          return {\n            year: y,\n            month: dm.month,\n            day: dm.day\n          };\n        }\n        /*\n         * for a candidate that includes a four-digit year,\n         * when the remaining integers don't match to a day and month,\n         * it is not a date.\n         */\n        return null;\n      }\n    }\n    // given no four-digit year, two digit years are the most flexible int to match, so\n    // try to parse a day-month out of integers[0..1] or integers[1..0]\n    for (let k = 0; k < possibleYearSplitsLength; k += 1) {\n      const [y, rest] = possibleYearSplits[k];\n      const dm = this.mapIntegersToDayMonth(rest);\n      if (dm != null) {\n        return {\n          year: this.twoToFourDigitYear(y),\n          month: dm.month,\n          day: dm.day\n        };\n      }\n    }\n    return null;\n  }\n  mapIntegersToDayMonth(integers) {\n    const temp = [integers, integers.slice().reverse()];\n    for (let i = 0; i < temp.length; i += 1) {\n      const data = temp[i];\n      const day = data[0];\n      const month = data[1];\n      if (day >= 1 && day <= 31 && month >= 1 && month <= 12) {\n        return {\n          day,\n          month\n        };\n      }\n    }\n    return null;\n  }\n  twoToFourDigitYear(year) {\n    if (year > 99) {\n      return year;\n    }\n    if (year > 50) {\n      // 87 -> 1987\n      return year + 1900;\n    }\n    // 15 -> 2015\n    return year + 2000;\n  }\n}\nexport { MatchDate as default };\n","const peq = new Uint32Array(0x10000);\nconst myers_32 = (a, b) => {\n  const n = a.length;\n  const m = b.length;\n  const lst = 1 << n - 1;\n  let pv = -1;\n  let mv = 0;\n  let sc = n;\n  let i = n;\n  while (i--) {\n    peq[a.charCodeAt(i)] |= 1 << i;\n  }\n  for (i = 0; i < m; i++) {\n    let eq = peq[b.charCodeAt(i)];\n    const xv = eq | mv;\n    eq |= (eq & pv) + pv ^ pv;\n    mv |= ~(eq | pv);\n    pv &= eq;\n    if (mv & lst) {\n      sc++;\n    }\n    if (pv & lst) {\n      sc--;\n    }\n    mv = mv << 1 | 1;\n    pv = pv << 1 | ~(xv | mv);\n    mv &= xv;\n  }\n  i = n;\n  while (i--) {\n    peq[a.charCodeAt(i)] = 0;\n  }\n  return sc;\n};\nconst myers_x = (b, a) => {\n  const n = a.length;\n  const m = b.length;\n  const mhc = [];\n  const phc = [];\n  const hsize = Math.ceil(n / 32);\n  const vsize = Math.ceil(m / 32);\n  for (let i = 0; i < hsize; i++) {\n    phc[i] = -1;\n    mhc[i] = 0;\n  }\n  let j = 0;\n  for (; j < vsize - 1; j++) {\n    let mv = 0;\n    let pv = -1;\n    const start = j * 32;\n    const vlen = Math.min(32, m) + start;\n    for (let k = start; k < vlen; k++) {\n      peq[b.charCodeAt(k)] |= 1 << k;\n    }\n    for (let i = 0; i < n; i++) {\n      const eq = peq[a.charCodeAt(i)];\n      const pb = phc[i / 32 | 0] >>> i & 1;\n      const mb = mhc[i / 32 | 0] >>> i & 1;\n      const xv = eq | mv;\n      const xh = ((eq | mb) & pv) + pv ^ pv | eq | mb;\n      let ph = mv | ~(xh | pv);\n      let mh = pv & xh;\n      if (ph >>> 31 ^ pb) {\n        phc[i / 32 | 0] ^= 1 << i;\n      }\n      if (mh >>> 31 ^ mb) {\n        mhc[i / 32 | 0] ^= 1 << i;\n      }\n      ph = ph << 1 | pb;\n      mh = mh << 1 | mb;\n      pv = mh | ~(xv | ph);\n      mv = ph & xv;\n    }\n    for (let k = start; k < vlen; k++) {\n      peq[b.charCodeAt(k)] = 0;\n    }\n  }\n  let mv = 0;\n  let pv = -1;\n  const start = j * 32;\n  const vlen = Math.min(32, m - start) + start;\n  for (let k = start; k < vlen; k++) {\n    peq[b.charCodeAt(k)] |= 1 << k;\n  }\n  let score = m;\n  for (let i = 0; i < n; i++) {\n    const eq = peq[a.charCodeAt(i)];\n    const pb = phc[i / 32 | 0] >>> i & 1;\n    const mb = mhc[i / 32 | 0] >>> i & 1;\n    const xv = eq | mv;\n    const xh = ((eq | mb) & pv) + pv ^ pv | eq | mb;\n    let ph = mv | ~(xh | pv);\n    let mh = pv & xh;\n    score += ph >>> m - 1 & 1;\n    score -= mh >>> m - 1 & 1;\n    if (ph >>> 31 ^ pb) {\n      phc[i / 32 | 0] ^= 1 << i;\n    }\n    if (mh >>> 31 ^ mb) {\n      mhc[i / 32 | 0] ^= 1 << i;\n    }\n    ph = ph << 1 | pb;\n    mh = mh << 1 | mb;\n    pv = mh | ~(xv | ph);\n    mv = ph & xv;\n  }\n  for (let k = start; k < vlen; k++) {\n    peq[b.charCodeAt(k)] = 0;\n  }\n  return score;\n};\nconst distance = (a, b) => {\n  if (a.length < b.length) {\n    const tmp = b;\n    b = a;\n    a = tmp;\n  }\n  if (b.length === 0) {\n    return a.length;\n  }\n  if (a.length <= 32) {\n    return myers_32(a, b);\n  }\n  return myers_x(a, b);\n};\nconst closest = (str, arr) => {\n  let min_distance = Infinity;\n  let min_index = 0;\n  for (let i = 0; i < arr.length; i++) {\n    const dist = distance(str, arr[i]);\n    if (dist < min_distance) {\n      min_distance = dist;\n      min_index = i;\n    }\n  }\n  return arr[min_index];\n};\nexport { closest, distance };","import { distance } from 'fastest-levenshtein';\nconst getUsedThreshold = (password, entry, threshold) => {\n  const isPasswordToShort = password.length <= entry.length;\n  const isThresholdLongerThanPassword = password.length <= threshold;\n  const shouldUsePasswordLength = isPasswordToShort || isThresholdLongerThanPassword;\n  // if password is too small use the password length divided by 4 while the threshold needs to be at least 1\n  return shouldUsePasswordLength ? Math.ceil(password.length / 4) : threshold;\n};\nconst findLevenshteinDistance = (password, rankedDictionary, threshold) => {\n  let foundDistance = 0;\n  const found = Object.keys(rankedDictionary).find(entry => {\n    const usedThreshold = getUsedThreshold(password, entry, threshold);\n    if (Math.abs(password.length - entry.length) > usedThreshold) {\n      return false;\n    }\n    const foundEntryDistance = distance(password, entry);\n    const isInThreshold = foundEntryDistance <= usedThreshold;\n    if (isInThreshold) {\n      foundDistance = foundEntryDistance;\n    }\n    return isInThreshold;\n  });\n  if (found) {\n    return {\n      levenshteinDistance: foundDistance,\n      levenshteinDistanceEntry: found\n    };\n  }\n  return {};\n};\nexport { findLevenshteinDistance as default };\n","var l33tTable = {\n  a: ['4', '@'],\n  b: ['8'],\n  c: ['(', '{', '[', '<'],\n  d: ['6', '|)'],\n  e: ['3'],\n  f: ['#'],\n  g: ['6', '9', '&'],\n  h: ['#', '|-|'],\n  i: ['1', '!', '|'],\n  k: ['<', '|<'],\n  l: ['!', '1', '|', '7'],\n  m: ['^^', 'nn', '2n', '/\\\\\\\\/\\\\\\\\'],\n  n: ['//'],\n  o: ['0', '()'],\n  q: ['9'],\n  u: ['|_|'],\n  s: ['$', '5'],\n  t: ['+', '7'],\n  v: ['<', '>', '/'],\n  w: ['^/', 'uu', 'vv', '2u', '2v', '\\\\\\\\/\\\\\\\\/'],\n  x: ['%', '><'],\n  z: ['2']\n};\nexport { l33tTable as default };\n","var translationKeys = {\n  warnings: {\n    straightRow: 'straightRow',\n    keyPattern: 'keyPattern',\n    simpleRepeat: 'simpleRepeat',\n    extendedRepeat: 'extendedRepeat',\n    sequences: 'sequences',\n    recentYears: 'recentYears',\n    dates: 'dates',\n    topTen: 'topTen',\n    topHundred: 'topHundred',\n    common: 'common',\n    similarToCommon: 'similarToCommon',\n    wordByItself: 'wordByItself',\n    namesByThemselves: 'namesByThemselves',\n    commonNames: 'commonNames',\n    userInputs: 'userInputs',\n    pwned: 'pwned'\n  },\n  suggestions: {\n    l33t: 'l33t',\n    reverseWords: 'reverseWords',\n    allUppercase: 'allUppercase',\n    capitalization: 'capitalization',\n    dates: 'dates',\n    recentYears: 'recentYears',\n    associatedYears: 'associatedYears',\n    sequences: 'sequences',\n    repeated: 'repeated',\n    longerKeyboardPattern: 'longerKeyboardPattern',\n    anotherWord: 'anotherWord',\n    useWords: 'useWords',\n    noNeed: 'noNeed',\n    pwned: 'pwned'\n  },\n  timeEstimation: {\n    ltSecond: 'ltSecond',\n    second: 'second',\n    seconds: 'seconds',\n    minute: 'minute',\n    minutes: 'minutes',\n    hour: 'hour',\n    hours: 'hours',\n    day: 'day',\n    days: 'days',\n    month: 'month',\n    months: 'months',\n    year: 'year',\n    years: 'years',\n    centuries: 'centuries'\n  }\n};\nexport { translationKeys as default };\n","class TrieNode {\n  constructor(parents = []) {\n    this.parents = parents;\n    // eslint-disable-next-line no-use-before-define\n    this.children = new Map();\n  }\n  addSub(key, ...subs) {\n    const firstChar = key.charAt(0);\n    if (!this.children.has(firstChar)) {\n      this.children.set(firstChar, new TrieNode([...this.parents, firstChar]));\n    }\n    let cur = this.children.get(firstChar);\n    for (let i = 1; i < key.length; i += 1) {\n      const c = key.charAt(i);\n      if (!cur.hasChild(c)) {\n        cur.addChild(c);\n      }\n      cur = cur.getChild(c);\n    }\n    cur.subs = (cur.subs || []).concat(subs);\n    return this;\n  }\n  getChild(child) {\n    return this.children.get(child);\n  }\n  isTerminal() {\n    return !!this.subs;\n  }\n  addChild(child) {\n    if (!this.hasChild(child)) {\n      this.children.set(child, new TrieNode([...this.parents, child]));\n    }\n  }\n  hasChild(child) {\n    return this.children.has(child);\n  }\n}\nexport { TrieNode as default };\n","var l33tTableToTrieNode = (l33tTable, triNode) => {\n  Object.entries(l33tTable).forEach(([letter, substitutions]) => {\n    substitutions.forEach(substitution => {\n      triNode.addSub(substitution, letter);\n    });\n  });\n  return triNode;\n};\nexport { l33tTableToTrieNode as default };\n","import { buildRankedDictionary } from './helper.esm.js';\nimport l33tTable from './data/l33tTable.esm.js';\nimport translationKeys from './data/translationKeys.esm.js';\nimport TrieNode from './matcher/dictionary/variants/matching/unmunger/TrieNode.esm.js';\nimport l33tTableToTrieNode from './matcher/dictionary/variants/matching/unmunger/l33tTableToTrieNode.esm.js';\nclass Options {\n  constructor() {\n    this.matchers = {};\n    this.l33tTable = l33tTable;\n    this.trieNodeRoot = l33tTableToTrieNode(l33tTable, new TrieNode());\n    this.dictionary = {\n      userInputs: []\n    };\n    this.rankedDictionaries = {};\n    this.rankedDictionariesMaxWordSize = {};\n    this.translations = translationKeys;\n    this.graphs = {};\n    this.useLevenshteinDistance = false;\n    this.levenshteinThreshold = 2;\n    this.l33tMaxSubstitutions = 100;\n    this.maxLength = 256;\n    this.setRankedDictionaries();\n  }\n  // eslint-disable-next-line max-statements,complexity\n  setOptions(options = {}) {\n    if (options.l33tTable) {\n      this.l33tTable = options.l33tTable;\n      this.trieNodeRoot = l33tTableToTrieNode(options.l33tTable, new TrieNode());\n    }\n    if (options.dictionary) {\n      this.dictionary = options.dictionary;\n      this.setRankedDictionaries();\n    }\n    if (options.translations) {\n      this.setTranslations(options.translations);\n    }\n    if (options.graphs) {\n      this.graphs = options.graphs;\n    }\n    if (options.useLevenshteinDistance !== undefined) {\n      this.useLevenshteinDistance = options.useLevenshteinDistance;\n    }\n    if (options.levenshteinThreshold !== undefined) {\n      this.levenshteinThreshold = options.levenshteinThreshold;\n    }\n    if (options.l33tMaxSubstitutions !== undefined) {\n      this.l33tMaxSubstitutions = options.l33tMaxSubstitutions;\n    }\n    if (options.maxLength !== undefined) {\n      this.maxLength = options.maxLength;\n    }\n  }\n  setTranslations(translations) {\n    if (this.checkCustomTranslations(translations)) {\n      this.translations = translations;\n    } else {\n      throw new Error('Invalid translations object fallback to keys');\n    }\n  }\n  checkCustomTranslations(translations) {\n    let valid = true;\n    Object.keys(translationKeys).forEach(type => {\n      if (type in translations) {\n        const translationType = type;\n        Object.keys(translationKeys[translationType]).forEach(key => {\n          if (!(key in translations[translationType])) {\n            valid = false;\n          }\n        });\n      } else {\n        valid = false;\n      }\n    });\n    return valid;\n  }\n  setRankedDictionaries() {\n    const rankedDictionaries = {};\n    const rankedDictionariesMaxWorkSize = {};\n    Object.keys(this.dictionary).forEach(name => {\n      rankedDictionaries[name] = buildRankedDictionary(this.dictionary[name]);\n      rankedDictionariesMaxWorkSize[name] = this.getRankedDictionariesMaxWordSize(this.dictionary[name]);\n    });\n    this.rankedDictionaries = rankedDictionaries;\n    this.rankedDictionariesMaxWordSize = rankedDictionariesMaxWorkSize;\n  }\n  getRankedDictionariesMaxWordSize(list) {\n    const data = list.map(el => {\n      if (typeof el !== 'string') {\n        return el.toString().length;\n      }\n      return el.length;\n    });\n    // do not use Math.max(...data) because it can result in max stack size error because every entry will be used as an argument\n    if (data.length === 0) {\n      return 0;\n    }\n    return data.reduce((a, b) => Math.max(a, b), -Infinity);\n  }\n  buildSanitizedRankedDictionary(list) {\n    const sanitizedInputs = [];\n    list.forEach(input => {\n      const inputType = typeof input;\n      if (inputType === 'string' || inputType === 'number' || inputType === 'boolean') {\n        sanitizedInputs.push(input.toString().toLowerCase());\n      }\n    });\n    return buildRankedDictionary(sanitizedInputs);\n  }\n  extendUserInputsDictionary(dictionary) {\n    if (!this.dictionary.userInputs) {\n      this.dictionary.userInputs = [];\n    }\n    const newList = [...this.dictionary.userInputs, ...dictionary];\n    this.rankedDictionaries.userInputs = this.buildSanitizedRankedDictionary(newList);\n    this.rankedDictionariesMaxWordSize.userInputs = this.getRankedDictionariesMaxWordSize(newList);\n  }\n  addMatcher(name, matcher) {\n    if (this.matchers[name]) {\n      console.info(`Matcher ${name} already exists`);\n    } else {\n      this.matchers[name] = matcher;\n    }\n  }\n}\nconst zxcvbnOptions = new Options();\nexport { Options, zxcvbnOptions };\n","/*\n * -------------------------------------------------------------------------------\n *  Dictionary reverse matching --------------------------------------------------\n * -------------------------------------------------------------------------------\n */\nclass MatchReverse {\n  constructor(defaultMatch) {\n    this.defaultMatch = defaultMatch;\n  }\n  match({\n    password\n  }) {\n    const passwordReversed = password.split('').reverse().join('');\n    return this.defaultMatch({\n      password: passwordReversed\n    }).map(match => ({\n      ...match,\n      token: match.token.split('').reverse().join(''),\n      reversed: true,\n      // map coordinates back to original string\n      i: password.length - 1 - match.j,\n      j: password.length - 1 - match.i\n    }));\n  }\n}\nexport { MatchReverse as default };\n","class CleanPasswords {\n  constructor({\n    substr,\n    limit,\n    trieRoot\n  }) {\n    this.buffer = [];\n    this.finalPasswords = [];\n    this.substr = substr;\n    this.limit = limit;\n    this.trieRoot = trieRoot;\n  }\n  getAllPossibleSubsAtIndex(index) {\n    const nodes = [];\n    let cur = this.trieRoot;\n    for (let i = index; i < this.substr.length; i += 1) {\n      const character = this.substr.charAt(i);\n      cur = cur.getChild(character);\n      if (!cur) {\n        break;\n      }\n      nodes.push(cur);\n    }\n    return nodes;\n  }\n  // eslint-disable-next-line complexity,max-statements\n  helper({\n    onlyFullSub,\n    isFullSub,\n    index,\n    subIndex,\n    changes,\n    lastSubLetter,\n    consecutiveSubCount\n  }) {\n    if (this.finalPasswords.length >= this.limit) {\n      return;\n    }\n    if (index === this.substr.length) {\n      if (onlyFullSub === isFullSub) {\n        this.finalPasswords.push({\n          password: this.buffer.join(''),\n          changes\n        });\n      }\n      return;\n    }\n    // first, exhaust all possible substitutions at this index\n    const nodes = [...this.getAllPossibleSubsAtIndex(index)];\n    let hasSubs = false;\n    // iterate backward to get wider substitutions first\n    for (let i = index + nodes.length - 1; i >= index; i -= 1) {\n      const cur = nodes[i - index];\n      if (cur.isTerminal()) {\n        // Skip if this would be a 4th or more consecutive substitution of the same letter\n        // this should work in all language as there shouldn't be the same letter more than four times in a row\n        // So we can ignore the rest to save calculation time\n        if (lastSubLetter === cur.parents.join('') && consecutiveSubCount >= 3) {\n          // eslint-disable-next-line no-continue\n          continue;\n        }\n        hasSubs = true;\n        const subs = cur.subs;\n        // eslint-disable-next-line no-restricted-syntax\n        for (const sub of subs) {\n          this.buffer.push(sub);\n          const newSubs = changes.concat({\n            i: subIndex,\n            letter: sub,\n            substitution: cur.parents.join('')\n          });\n          // recursively build the rest of the string\n          this.helper({\n            onlyFullSub,\n            isFullSub,\n            index: i + 1,\n            subIndex: subIndex + sub.length,\n            changes: newSubs,\n            lastSubLetter: cur.parents.join(''),\n            consecutiveSubCount: lastSubLetter === cur.parents.join('') ? consecutiveSubCount + 1 : 1\n          });\n          // backtrack by ignoring the added postfix\n          this.buffer.pop();\n          if (this.finalPasswords.length >= this.limit) {\n            return;\n          }\n        }\n      }\n    }\n    // next, generate all combos without doing a substitution at this index\n    // if a partial substitution is requested or there are no substitutions at this index\n    if (!onlyFullSub || !hasSubs) {\n      const firstChar = this.substr.charAt(index);\n      this.buffer.push(firstChar);\n      this.helper({\n        onlyFullSub,\n        isFullSub: isFullSub && !hasSubs,\n        index: index + 1,\n        subIndex: subIndex + 1,\n        changes,\n        lastSubLetter,\n        consecutiveSubCount\n      });\n      this.buffer.pop();\n    }\n  }\n  getAll() {\n    // only full substitution\n    this.helper({\n      onlyFullSub: true,\n      isFullSub: true,\n      index: 0,\n      subIndex: 0,\n      changes: [],\n      lastSubLetter: undefined,\n      consecutiveSubCount: 0\n    });\n    // only partial substitution\n    this.helper({\n      onlyFullSub: false,\n      isFullSub: true,\n      index: 0,\n      subIndex: 0,\n      changes: [],\n      lastSubLetter: undefined,\n      consecutiveSubCount: 0\n    });\n    return this.finalPasswords;\n  }\n}\nconst getCleanPasswords = (password, limit, trieRoot) => {\n  const helper = new CleanPasswords({\n    substr: password,\n    limit,\n    trieRoot\n  });\n  return helper.getAll();\n};\nexport { getCleanPasswords as default };\n","import { zxcvbnOptions } from '../../../../Options.esm.js';\nimport getCleanPasswords from './unmunger/getCleanPasswords.esm.js';\nconst getExtras = (passwordWithSubs, i, j) => {\n  const previousChanges = passwordWithSubs.changes.filter(changes => {\n    return changes.i < i;\n  });\n  const iUnsubbed = previousChanges.reduce((value, change) => {\n    return value - change.letter.length + change.substitution.length;\n  }, i);\n  const usedChanges = passwordWithSubs.changes.filter(changes => {\n    return changes.i >= i && changes.i <= j;\n  });\n  const jUnsubbed = usedChanges.reduce((value, change) => {\n    return value - change.letter.length + change.substitution.length;\n  }, j - i + iUnsubbed);\n  const filtered = [];\n  const subDisplay = [];\n  usedChanges.forEach(value => {\n    const existingIndex = filtered.findIndex(t => {\n      return t.letter === value.letter && t.substitution === value.substitution;\n    });\n    if (existingIndex < 0) {\n      filtered.push({\n        letter: value.letter,\n        substitution: value.substitution\n      });\n      subDisplay.push(`${value.substitution} -> ${value.letter}`);\n    }\n  });\n  return {\n    i: iUnsubbed,\n    j: jUnsubbed,\n    subs: filtered,\n    subDisplay: subDisplay.join(', ')\n  };\n};\n/*\n * -------------------------------------------------------------------------------\n *  Dictionary l33t matching -----------------------------------------------------\n * -------------------------------------------------------------------------------\n */\nclass MatchL33t {\n  constructor(defaultMatch) {\n    this.defaultMatch = defaultMatch;\n  }\n  isAlreadyIncluded(matches, newMatch) {\n    return matches.some(l33tMatch => {\n      return Object.entries(l33tMatch).every(([key, value]) => {\n        return key === 'subs' || value === newMatch[key];\n      });\n    });\n  }\n  match({\n    password\n  }) {\n    const matches = [];\n    const subbedPasswords = getCleanPasswords(password, zxcvbnOptions.l33tMaxSubstitutions, zxcvbnOptions.trieNodeRoot);\n    let hasFullMatch = false;\n    let isFullSubstitution = true;\n    subbedPasswords.forEach(subbedPassword => {\n      if (hasFullMatch) {\n        return;\n      }\n      const matchedDictionary = this.defaultMatch({\n        password: subbedPassword.password,\n        useLevenshtein: isFullSubstitution\n      });\n      // only the first entry has a full substitution\n      isFullSubstitution = false;\n      matchedDictionary.forEach(match => {\n        if (!hasFullMatch) {\n          hasFullMatch = match.i === 0 && match.j === password.length - 1;\n        }\n        const extras = getExtras(subbedPassword, match.i, match.j);\n        const token = password.slice(extras.i, +extras.j + 1 || 9e9);\n        const newMatch = {\n          ...match,\n          l33t: true,\n          token,\n          ...extras\n        };\n        const alreadyIncluded = this.isAlreadyIncluded(matches, newMatch);\n        // only return the matches that contain an actual substitution\n        if (token.toLowerCase() !== match.matchedWord && !alreadyIncluded) {\n          matches.push(newMatch);\n        }\n      });\n    });\n    // filter single-character l33t matches to reduce noise.\n    // otherwise '1' matches 'i', '4' matches 'a', both very common English words\n    // with low dictionary rank.\n    return matches.filter(match => match.token.length > 1);\n  }\n}\nexport { MatchL33t as default };\n","import findLevenshteinDistance from '../../levenshtein.esm.js';\nimport { sorted } from '../../helper.esm.js';\nimport { zxcvbnOptions } from '../../Options.esm.js';\nimport MatchReverse from './variants/matching/reverse.esm.js';\nimport MatchL33t from './variants/matching/l33t.esm.js';\nclass MatchDictionary {\n  constructor() {\n    this.l33t = new MatchL33t(this.defaultMatch);\n    this.reverse = new MatchReverse(this.defaultMatch);\n  }\n  match({\n    password\n  }) {\n    const matches = [...this.defaultMatch({\n      password\n    }), ...this.reverse.match({\n      password\n    }), ...this.l33t.match({\n      password\n    })];\n    return sorted(matches);\n  }\n  defaultMatch({\n    password,\n    useLevenshtein = true\n  }) {\n    const matches = [];\n    const passwordLength = password.length;\n    const passwordLower = password.toLowerCase();\n    // eslint-disable-next-line complexity,max-statements\n    Object.keys(zxcvbnOptions.rankedDictionaries).forEach(dictionaryName => {\n      const rankedDict = zxcvbnOptions.rankedDictionaries[dictionaryName];\n      const longestDictionaryWordSize = zxcvbnOptions.rankedDictionariesMaxWordSize[dictionaryName];\n      const searchWidth = Math.min(longestDictionaryWordSize, passwordLength);\n      for (let i = 0; i < passwordLength; i += 1) {\n        const searchEnd = Math.min(i + searchWidth, passwordLength);\n        for (let j = i; j < searchEnd; j += 1) {\n          const usedPassword = passwordLower.slice(i, +j + 1 || 9e9);\n          const isInDictionary = usedPassword in rankedDict;\n          let foundLevenshteinDistance = {};\n          // only use levenshtein distance on full password to minimize the performance drop\n          // and because otherwise there would be to many false positives\n          const isFullPassword = i === 0 && j === passwordLength - 1;\n          if (zxcvbnOptions.useLevenshteinDistance && isFullPassword && !isInDictionary && useLevenshtein) {\n            foundLevenshteinDistance = findLevenshteinDistance(usedPassword, rankedDict, zxcvbnOptions.levenshteinThreshold);\n          }\n          const isLevenshteinMatch = Object.keys(foundLevenshteinDistance).length !== 0;\n          if (isInDictionary || isLevenshteinMatch) {\n            const usedRankPassword = isLevenshteinMatch ? foundLevenshteinDistance.levenshteinDistanceEntry : usedPassword;\n            const rank = rankedDict[usedRankPassword];\n            matches.push({\n              pattern: 'dictionary',\n              i,\n              j,\n              token: password.slice(i, +j + 1 || 9e9),\n              matchedWord: usedPassword,\n              rank,\n              dictionaryName: dictionaryName,\n              reversed: false,\n              l33t: false,\n              ...foundLevenshteinDistance\n            });\n          }\n        }\n      }\n    });\n    return matches;\n  }\n}\nexport { MatchDictionary as default };\n","import { REGEXEN } from '../../data/const.esm.js';\nimport { sorted } from '../../helper.esm.js';\n\n/*\n * -------------------------------------------------------------------------------\n *  regex matching ---------------------------------------------------------------\n * -------------------------------------------------------------------------------\n */\nclass MatchRegex {\n  match({\n    password,\n    regexes = REGEXEN\n  }) {\n    const matches = [];\n    Object.keys(regexes).forEach(name => {\n      const regex = regexes[name];\n      regex.lastIndex = 0; // keeps regexMatch stateless\n      let regexMatch;\n      // eslint-disable-next-line no-cond-assign\n      while (regexMatch = regex.exec(password)) {\n        if (regexMatch) {\n          const token = regexMatch[0];\n          matches.push({\n            pattern: 'regex',\n            token,\n            i: regexMatch.index,\n            j: regexMatch.index + regexMatch[0].length - 1,\n            regexName: name,\n            regexMatch\n          });\n        }\n      }\n    });\n    return sorted(matches);\n  }\n}\nexport { MatchRegex as default };\n","var utils = {\n  // binomial coefficients\n  // src: http://blog.plover.com/math/choose.html\n  nCk(n, k) {\n    let count = n;\n    if (k > count) {\n      return 0;\n    }\n    if (k === 0) {\n      return 1;\n    }\n    let coEff = 1;\n    for (let i = 1; i <= k; i += 1) {\n      coEff *= count;\n      coEff /= i;\n      count -= 1;\n    }\n    return coEff;\n  },\n  log10(n) {\n    if (n === 0) return 0;\n    return Math.log(n) / Math.log(10); // IE doesn't support Math.log10 :(\n  },\n  log2(n) {\n    return Math.log(n) / Math.log(2);\n  },\n  factorial(num) {\n    let rval = 1;\n    for (let i = 2; i <= num; i += 1) rval *= i;\n    return rval;\n  }\n};\nexport { utils as default };\n","import { BRUTEFORCE_CARDINALITY, MIN_SUBMATCH_GUESSES_SINGLE_CHAR, MIN_SUBMATCH_GUESSES_MULTI_CHAR } from '../../data/const.esm.js';\nvar bruteforceMatcher = ({\n  token\n}) => {\n  let guesses = BRUTEFORCE_CARDINALITY ** token.length;\n  if (guesses === Number.POSITIVE_INFINITY) {\n    guesses = Number.MAX_VALUE;\n  }\n  let minGuesses;\n  // small detail: make bruteforce matches at minimum one guess bigger than smallest allowed\n  // submatch guesses, such that non-bruteforce submatches over the same [i..j] take precedence.\n  if (token.length === 1) {\n    minGuesses = MIN_SUBMATCH_GUESSES_SINGLE_CHAR + 1;\n  } else {\n    minGuesses = MIN_SUBMATCH_GUESSES_MULTI_CHAR + 1;\n  }\n  return Math.max(guesses, minGuesses);\n};\nexport { bruteforceMatcher as default };\n","import { REFERENCE_YEAR, MIN_YEAR_SPACE } from '../../data/const.esm.js';\nvar dateMatcher = ({\n  year,\n  separator\n}) => {\n  // base guesses: (year distance from REFERENCE_YEAR) * num_days * num_years\n  const yearSpace = Math.max(Math.abs(year - REFERENCE_YEAR), MIN_YEAR_SPACE);\n  let guesses = yearSpace * 365;\n  // add factor of 4 for separator selection (one of ~4 choices)\n  if (separator) {\n    guesses *= 4;\n  }\n  return guesses;\n};\nexport { dateMatcher as default };\n","import utils from '../../../../scoring/utils.esm.js';\nimport { ALPHA_INVERTED, ALL_LOWER_INVERTED, ONE_UPPER, ONE_LOWER, START_UPPER, END_UPPER, ALL_UPPER_INVERTED } from '../../../../data/const.esm.js';\nconst getVariations = cleanedWord => {\n  const wordArray = cleanedWord.split('');\n  const upperCaseCount = wordArray.filter(char => char.match(ONE_UPPER)).length;\n  const lowerCaseCount = wordArray.filter(char => char.match(ONE_LOWER)).length;\n  let variations = 0;\n  const variationLength = Math.min(upperCaseCount, lowerCaseCount);\n  for (let i = 1; i <= variationLength; i += 1) {\n    variations += utils.nCk(upperCaseCount + lowerCaseCount, i);\n  }\n  return variations;\n};\nvar uppercaseVariant = word => {\n  // clean words of non alpha characters to remove the reward effekt to capitalize the first letter https://github.com/dropbox/zxcvbn/issues/232\n  const cleanedWord = word.replace(ALPHA_INVERTED, '');\n  if (cleanedWord.match(ALL_LOWER_INVERTED) || cleanedWord.toLowerCase() === cleanedWord) {\n    return 1;\n  }\n  // a capitalized word is the most common capitalization scheme,\n  // so it only doubles the search space (uncapitalized + capitalized).\n  // all caps and end-capitalized are common enough too, underestimate as 2x factor to be safe.\n  const commonCases = [START_UPPER, END_UPPER, ALL_UPPER_INVERTED];\n  const commonCasesLength = commonCases.length;\n  for (let i = 0; i < commonCasesLength; i += 1) {\n    const regex = commonCases[i];\n    if (cleanedWord.match(regex)) {\n      return 2;\n    }\n  }\n  // otherwise calculate the number of ways to capitalize U+L uppercase+lowercase letters\n  // with U uppercase letters or less. or, if there's more uppercase than lower (for eg. PASSwORD),\n  // the number of ways to lowercase U+L letters with L lowercase letters or less.\n  return getVariations(cleanedWord);\n};\nexport { uppercaseVariant as default };\n","import utils from '../../../../scoring/utils.esm.js';\nconst countSubstring = (string, substring) => {\n  let count = 0;\n  let pos = string.indexOf(substring);\n  while (pos >= 0) {\n    count += 1;\n    pos = string.indexOf(substring, pos + substring.length);\n  }\n  return count;\n};\nconst getCounts = ({\n  sub,\n  token\n}) => {\n  // lower-case match.token before calculating: capitalization shouldn't affect l33t calc.\n  const tokenLower = token.toLowerCase();\n  // num of subbed chars\n  const subbedCount = countSubstring(tokenLower, sub.substitution);\n  // num of unsubbed chars\n  const unsubbedCount = countSubstring(tokenLower, sub.letter);\n  return {\n    subbedCount,\n    unsubbedCount\n  };\n};\nvar l33tVariant = ({\n  l33t,\n  subs,\n  token\n}) => {\n  if (!l33t) {\n    return 1;\n  }\n  let variations = 1;\n  subs.forEach(sub => {\n    const {\n      subbedCount,\n      unsubbedCount\n    } = getCounts({\n      sub,\n      token\n    });\n    if (subbedCount === 0 || unsubbedCount === 0) {\n      // for this sub, password is either fully subbed (444) or fully unsubbed (aaa)\n      // treat that as doubling the space (attacker needs to try fully subbed chars in addition to\n      // unsubbed.)\n      variations *= 2;\n    } else {\n      // this case is similar to capitalization:\n      // with aa44a, U = 3, S = 2, attacker needs to try unsubbed + one sub + two subs\n      const p = Math.min(unsubbedCount, subbedCount);\n      let possibilities = 0;\n      for (let i = 1; i <= p; i += 1) {\n        possibilities += utils.nCk(unsubbedCount + subbedCount, i);\n      }\n      variations *= possibilities;\n    }\n  });\n  return variations;\n};\nexport { l33tVariant as default };\n","import uppercaseVariant from './variants/scoring/uppercase.esm.js';\nimport l33tVariant from './variants/scoring/l33t.esm.js';\nvar dictionaryMatcher = ({\n  rank,\n  reversed,\n  l33t,\n  subs,\n  token,\n  dictionaryName\n}) => {\n  const baseGuesses = rank; // keep these as properties for display purposes\n  const uppercaseVariations = uppercaseVariant(token);\n  const l33tVariations = l33tVariant({\n    l33t,\n    subs,\n    token\n  });\n  const reversedVariations = reversed && 2 || 1;\n  let calculation;\n  if (dictionaryName === 'diceware') {\n    // diceware dictionaries are special, so we get a simple scoring of 1/2 of 6^5 (6 digits on 5 dice)\n    // to get fix entropy of ~12.9 bits for every entry https://en.wikipedia.org/wiki/Diceware#:~:text=The%20level%20of,bits\n    calculation = 6 ** 5 / 2;\n  } else {\n    calculation = baseGuesses * uppercaseVariations * l33tVariations * reversedVariations;\n  }\n  return {\n    baseGuesses,\n    uppercaseVariations,\n    l33tVariations,\n    calculation\n  };\n};\nexport { dictionaryMatcher as default };\n","import { REFERENCE_YEAR, MIN_YEAR_SPACE } from '../../data/const.esm.js';\nvar regexMatcher = ({\n  regexName,\n  regexMatch,\n  token\n}) => {\n  const charClassBases = {\n    alphaLower: 26,\n    alphaUpper: 26,\n    alpha: 52,\n    alphanumeric: 62,\n    digits: 10,\n    symbols: 33\n  };\n  if (regexName in charClassBases) {\n    return charClassBases[regexName] ** token.length;\n  }\n  // TODO add more regex types for example special dates like 09.11\n  // eslint-disable-next-line default-case\n  switch (regexName) {\n    case 'recentYear':\n      // conservative estimate of year space: num years from REFERENCE_YEAR.\n      // if year is close to REFERENCE_YEAR, estimate a year space of MIN_YEAR_SPACE.\n      return Math.max(Math.abs(parseInt(regexMatch[0], 10) - REFERENCE_YEAR), MIN_YEAR_SPACE);\n  }\n  return 0;\n};\nexport { regexMatcher as default };\n","var repeatMatcher = ({\n  baseGuesses,\n  repeatCount\n}) => baseGuesses * repeatCount;\nexport { repeatMatcher as default };\n","var sequenceMatcher = ({\n  token,\n  ascending\n}) => {\n  const firstChr = token.charAt(0);\n  let baseGuesses = 0;\n  const startingPoints = ['a', 'A', 'z', 'Z', '0', '1', '9'];\n  // lower guesses for obvious starting points\n  if (startingPoints.includes(firstChr)) {\n    baseGuesses = 4;\n  } else if (firstChr.match(/\\d/)) {\n    baseGuesses = 10; // digits\n  } else {\n    // could give a higher base for uppercase,\n    // assigning 26 to both upper and lower sequences is more conservative.\n    baseGuesses = 26;\n  }\n  // need to try a descending sequence in addition to every ascending sequence ->\n  // 2x guesses\n  if (!ascending) {\n    baseGuesses *= 2;\n  }\n  return baseGuesses * token.length;\n};\nexport { sequenceMatcher as default };\n","import utils from '../../scoring/utils.esm.js';\nimport { zxcvbnOptions } from '../../Options.esm.js';\nconst calcAverageDegree = graph => {\n  let average = 0;\n  Object.keys(graph).forEach(key => {\n    const neighbors = graph[key];\n    average += neighbors.filter(entry => !!entry).length;\n  });\n  average /= Object.entries(graph).length;\n  return average;\n};\nconst estimatePossiblePatterns = ({\n  token,\n  graph,\n  turns\n}) => {\n  const startingPosition = Object.keys(zxcvbnOptions.graphs[graph]).length;\n  const averageDegree = calcAverageDegree(zxcvbnOptions.graphs[graph]);\n  let guesses = 0;\n  const tokenLength = token.length;\n  // # estimate the number of possible patterns w/ tokenLength or less with turns or less.\n  for (let i = 2; i <= tokenLength; i += 1) {\n    const possibleTurns = Math.min(turns, i - 1);\n    for (let j = 1; j <= possibleTurns; j += 1) {\n      guesses += utils.nCk(i - 1, j - 1) * startingPosition * averageDegree ** j;\n    }\n  }\n  return guesses;\n};\nvar spatialMatcher = ({\n  graph,\n  token,\n  shiftedCount,\n  turns\n}) => {\n  let guesses = estimatePossiblePatterns({\n    token,\n    graph,\n    turns\n  });\n  // add extra guesses for shifted keys. (% instead of 5, A instead of a.)\n  // math is similar to extra guesses of l33t substitutions in dictionary matches.\n  if (shiftedCount) {\n    const unShiftedCount = token.length - shiftedCount;\n    if (shiftedCount === 0 || unShiftedCount === 0) {\n      guesses *= 2;\n    } else {\n      let shiftedVariations = 0;\n      for (let i = 1; i <= Math.min(shiftedCount, unShiftedCount); i += 1) {\n        shiftedVariations += utils.nCk(shiftedCount + unShiftedCount, i);\n      }\n      guesses *= shiftedVariations;\n    }\n  }\n  return Math.round(guesses);\n};\nexport { spatialMatcher as default };\n","import { SEPERATOR_CHAR_COUNT } from '../../data/const.esm.js';\nvar separatorMatcher = () => {\n  return SEPERATOR_CHAR_COUNT;\n};\nexport { separatorMatcher as default };\n","import { MIN_SUBMATCH_GUESSES_SINGLE_CHAR, MIN_SUBMATCH_GUESSES_MULTI_CHAR } from '../data/const.esm.js';\nimport utils from './utils.esm.js';\nimport { zxcvbnOptions } from '../Options.esm.js';\nimport bruteforceMatcher from '../matcher/bruteforce/scoring.esm.js';\nimport dateMatcher from '../matcher/date/scoring.esm.js';\nimport dictionaryMatcher from '../matcher/dictionary/scoring.esm.js';\nimport regexMatcher from '../matcher/regex/scoring.esm.js';\nimport repeatMatcher from '../matcher/repeat/scoring.esm.js';\nimport sequenceMatcher from '../matcher/sequence/scoring.esm.js';\nimport spatialMatcher from '../matcher/spatial/scoring.esm.js';\nimport separatorMatcher from '../matcher/separator/scoring.esm.js';\nconst getMinGuesses = (match, password) => {\n  let minGuesses = 1;\n  if (match.token.length < password.length) {\n    if (match.token.length === 1) {\n      minGuesses = MIN_SUBMATCH_GUESSES_SINGLE_CHAR;\n    } else {\n      minGuesses = MIN_SUBMATCH_GUESSES_MULTI_CHAR;\n    }\n  }\n  return minGuesses;\n};\nconst matchers = {\n  bruteforce: bruteforceMatcher,\n  date: dateMatcher,\n  dictionary: dictionaryMatcher,\n  regex: regexMatcher,\n  repeat: repeatMatcher,\n  sequence: sequenceMatcher,\n  spatial: spatialMatcher,\n  separator: separatorMatcher\n};\nconst getScoring = (name, match) => {\n  if (matchers[name]) {\n    return matchers[name](match);\n  }\n  if (zxcvbnOptions.matchers[name] && 'scoring' in zxcvbnOptions.matchers[name]) {\n    return zxcvbnOptions.matchers[name].scoring(match);\n  }\n  return 0;\n};\n// ------------------------------------------------------------------------------\n// guess estimation -- one function per match pattern ---------------------------\n// ------------------------------------------------------------------------------\n// eslint-disable-next-line complexity, max-statements\nvar estimateGuesses = (match, password) => {\n  const extraData = {};\n  // a match's guess estimate doesn't change. cache it.\n  if ('guesses' in match && match.guesses != null) {\n    return match;\n  }\n  const minGuesses = getMinGuesses(match, password);\n  const estimationResult = getScoring(match.pattern, match);\n  let guesses = 0;\n  if (typeof estimationResult === 'number') {\n    guesses = estimationResult;\n  } else if (match.pattern === 'dictionary') {\n    guesses = estimationResult.calculation;\n    extraData.baseGuesses = estimationResult.baseGuesses;\n    extraData.uppercaseVariations = estimationResult.uppercaseVariations;\n    extraData.l33tVariations = estimationResult.l33tVariations;\n  }\n  const matchGuesses = Math.max(guesses, minGuesses);\n  return {\n    ...match,\n    ...extraData,\n    guesses: matchGuesses,\n    guessesLog10: utils.log10(matchGuesses)\n  };\n};\nexport { estimateGuesses as default };\n","import utils from './utils.esm.js';\nimport estimateGuesses from './estimate.esm.js';\nimport { MIN_GUESSES_BEFORE_GROWING_SEQUENCE } from '../data/const.esm.js';\nconst scoringHelper = {\n  password: '',\n  optimal: {},\n  excludeAdditive: false,\n  separatorRegex: undefined,\n  fillArray(size, valueType) {\n    const result = [];\n    for (let i = 0; i < size; i += 1) {\n      let value = [];\n      if (valueType === 'object') {\n        value = {};\n      }\n      result.push(value);\n    }\n    return result;\n  },\n  // helper: make bruteforce match objects spanning i to j, inclusive.\n  makeBruteforceMatch(i, j) {\n    return {\n      pattern: 'bruteforce',\n      token: this.password.slice(i, +j + 1 || 9e9),\n      i,\n      j\n    };\n  },\n  // helper: considers whether a length-sequenceLength\n  // sequence ending at match m is better (fewer guesses)\n  // than previously encountered sequences, updating state if so.\n  update(match, sequenceLength) {\n    const k = match.j;\n    const estimatedMatch = estimateGuesses(match, this.password);\n    let pi = estimatedMatch.guesses;\n    if (sequenceLength > 1) {\n      // we're considering a length-sequenceLength sequence ending with match m:\n      // obtain the product term in the minimization function by multiplying m's guesses\n      // by the product of the length-(sequenceLength-1)\n      // sequence ending just before m, at m.i - 1.\n      pi *= this.optimal.pi[estimatedMatch.i - 1][sequenceLength - 1];\n    }\n    // calculate the minimization func\n    let g = utils.factorial(sequenceLength) * pi;\n    if (!this.excludeAdditive) {\n      g += MIN_GUESSES_BEFORE_GROWING_SEQUENCE ** (sequenceLength - 1);\n    }\n    // update state if new best.\n    // first see if any competing sequences covering this prefix,\n    // with sequenceLength or fewer matches,\n    // fare better than this sequence. if so, skip it and return.\n    let shouldSkip = false;\n    Object.keys(this.optimal.g[k]).forEach(competingPatternLength => {\n      const competingMetricMatch = this.optimal.g[k][competingPatternLength];\n      if (parseInt(competingPatternLength, 10) <= sequenceLength) {\n        if (competingMetricMatch <= g) {\n          shouldSkip = true;\n        }\n      }\n    });\n    if (!shouldSkip) {\n      // this sequence might be part of the final optimal sequence.\n      this.optimal.g[k][sequenceLength] = g;\n      this.optimal.m[k][sequenceLength] = estimatedMatch;\n      this.optimal.pi[k][sequenceLength] = pi;\n    }\n  },\n  // helper: evaluate bruteforce matches ending at passwordCharIndex.\n  bruteforceUpdate(passwordCharIndex) {\n    // see if a single bruteforce match spanning the passwordCharIndex-prefix is optimal.\n    let match = this.makeBruteforceMatch(0, passwordCharIndex);\n    this.update(match, 1);\n    for (let i = 1; i <= passwordCharIndex; i += 1) {\n      // generate passwordCharIndex bruteforce matches, spanning from (i=1, j=passwordCharIndex) up to (i=passwordCharIndex, j=passwordCharIndex).\n      // see if adding these new matches to any of the sequences in optimal[i-1]\n      // leads to new bests.\n      match = this.makeBruteforceMatch(i, passwordCharIndex);\n      const tmp = this.optimal.m[i - 1];\n      // eslint-disable-next-line no-loop-func\n      Object.keys(tmp).forEach(sequenceLength => {\n        const lastMatch = tmp[sequenceLength];\n        // corner: an optimal sequence will never have two adjacent bruteforce matches.\n        // it is strictly better to have a single bruteforce match spanning the same region:\n        // same contribution to the guess product with a lower length.\n        // --> safe to skip those cases.\n        if (lastMatch.pattern !== 'bruteforce') {\n          // try adding m to this length-sequenceLength sequence.\n          this.update(match, parseInt(sequenceLength, 10) + 1);\n        }\n      });\n    }\n  },\n  // helper: step backwards through optimal.m starting at the end,\n  // constructing the final optimal match sequence.\n  unwind(passwordLength) {\n    const optimalMatchSequence = [];\n    let k = passwordLength - 1;\n    // find the final best sequence length and score\n    let sequenceLength = 0;\n    // eslint-disable-next-line no-loss-of-precision\n    let g = 2e308;\n    const temp = this.optimal.g[k];\n    // safety check for empty passwords\n    if (temp) {\n      Object.keys(temp).forEach(candidateSequenceLength => {\n        const candidateMetricMatch = temp[candidateSequenceLength];\n        if (candidateMetricMatch < g) {\n          sequenceLength = parseInt(candidateSequenceLength, 10);\n          g = candidateMetricMatch;\n        }\n      });\n    }\n    while (k >= 0) {\n      const match = this.optimal.m[k][sequenceLength];\n      optimalMatchSequence.unshift(match);\n      k = match.i - 1;\n      sequenceLength -= 1;\n    }\n    return optimalMatchSequence;\n  }\n};\nvar scoring = {\n  // ------------------------------------------------------------------------------\n  // search --- most guessable match sequence -------------------------------------\n  // ------------------------------------------------------------------------------\n  //\n  // takes a sequence of overlapping matches, returns the non-overlapping sequence with\n  // minimum guesses. the following is a O(l_max * (n + m)) dynamic programming algorithm\n  // for a length-n password with m candidate matches. l_max is the maximum optimal\n  // sequence length spanning each prefix of the password. In practice it rarely exceeds 5 and the\n  // search terminates rapidly.\n  //\n  // the optimal \"minimum guesses\" sequence is here defined to be the sequence that\n  // minimizes the following function:\n  //\n  //    g = sequenceLength! * Product(m.guesses for m in sequence) + D^(sequenceLength - 1)\n  //\n  // where sequenceLength is the length of the sequence.\n  //\n  // the factorial term is the number of ways to order sequenceLength patterns.\n  //\n  // the D^(sequenceLength-1) term is another length penalty, roughly capturing the idea that an\n  // attacker will try lower-length sequences first before trying length-sequenceLength sequences.\n  //\n  // for example, consider a sequence that is date-repeat-dictionary.\n  //  - an attacker would need to try other date-repeat-dictionary combinations,\n  //    hence the product term.\n  //  - an attacker would need to try repeat-date-dictionary, dictionary-repeat-date,\n  //    ..., hence the factorial term.\n  //  - an attacker would also likely try length-1 (dictionary) and length-2 (dictionary-date)\n  //    sequences before length-3. assuming at minimum D guesses per pattern type,\n  //    D^(sequenceLength-1) approximates Sum(D^i for i in [1..sequenceLength-1]\n  //\n  // ------------------------------------------------------------------------------\n  mostGuessableMatchSequence(password, matches, excludeAdditive = false) {\n    scoringHelper.password = password;\n    scoringHelper.excludeAdditive = excludeAdditive;\n    const passwordLength = password.length;\n    // partition matches into sublists according to ending index j\n    let matchesByCoordinateJ = scoringHelper.fillArray(passwordLength, 'array');\n    matches.forEach(match => {\n      matchesByCoordinateJ[match.j].push(match);\n    });\n    // small detail: for deterministic output, sort each sublist by i.\n    matchesByCoordinateJ = matchesByCoordinateJ.map(match => match.sort((m1, m2) => m1.i - m2.i));\n    scoringHelper.optimal = {\n      // optimal.m[k][sequenceLength] holds final match in the best length-sequenceLength\n      // match sequence covering the\n      // password prefix up to k, inclusive.\n      // if there is no length-sequenceLength sequence that scores better (fewer guesses) than\n      // a shorter match sequence spanning the same prefix,\n      // optimal.m[k][sequenceLength] is undefined.\n      m: scoringHelper.fillArray(passwordLength, 'object'),\n      // same structure as optimal.m -- holds the product term Prod(m.guesses for m in sequence).\n      // optimal.pi allows for fast (non-looping) updates to the minimization function.\n      pi: scoringHelper.fillArray(passwordLength, 'object'),\n      // same structure as optimal.m -- holds the overall metric.\n      g: scoringHelper.fillArray(passwordLength, 'object')\n    };\n    for (let k = 0; k < passwordLength; k += 1) {\n      matchesByCoordinateJ[k].forEach(match => {\n        if (match.i > 0) {\n          Object.keys(scoringHelper.optimal.m[match.i - 1]).forEach(sequenceLength => {\n            scoringHelper.update(match, parseInt(sequenceLength, 10) + 1);\n          });\n        } else {\n          scoringHelper.update(match, 1);\n        }\n      });\n      scoringHelper.bruteforceUpdate(k);\n    }\n    const optimalMatchSequence = scoringHelper.unwind(passwordLength);\n    const optimalSequenceLength = optimalMatchSequence.length;\n    const guesses = this.getGuesses(password, optimalSequenceLength);\n    return {\n      password,\n      guesses,\n      guessesLog10: utils.log10(guesses),\n      sequence: optimalMatchSequence\n    };\n  },\n  getGuesses(password, optimalSequenceLength) {\n    const passwordLength = password.length;\n    let guesses = 0;\n    if (password.length === 0) {\n      guesses = 1;\n    } else {\n      guesses = scoringHelper.optimal.g[passwordLength - 1][optimalSequenceLength];\n    }\n    return guesses;\n  }\n};\nexport { scoring as default };\n","import scoring from '../../scoring/index.esm.js';\n\n/*\n *-------------------------------------------------------------------------------\n * repeats (aaa, abcabcabc) ------------------------------\n *-------------------------------------------------------------------------------\n */\nclass MatchRepeat {\n  // eslint-disable-next-line max-statements\n  match({\n    password,\n    omniMatch\n  }) {\n    const matches = [];\n    let lastIndex = 0;\n    while (lastIndex < password.length) {\n      const greedyMatch = this.getGreedyMatch(password, lastIndex);\n      const lazyMatch = this.getLazyMatch(password, lastIndex);\n      if (greedyMatch == null) {\n        break;\n      }\n      const {\n        match,\n        baseToken\n      } = this.setMatchToken(greedyMatch, lazyMatch);\n      if (match) {\n        const j = match.index + match[0].length - 1;\n        const baseGuesses = this.getBaseGuesses(baseToken, omniMatch);\n        matches.push(this.normalizeMatch(baseToken, j, match, baseGuesses));\n        lastIndex = j + 1;\n      }\n    }\n    const hasPromises = matches.some(match => {\n      return match instanceof Promise;\n    });\n    if (hasPromises) {\n      return Promise.all(matches);\n    }\n    return matches;\n  }\n  // eslint-disable-next-line max-params\n  normalizeMatch(baseToken, j, match, baseGuesses) {\n    const baseMatch = {\n      pattern: 'repeat',\n      i: match.index,\n      j,\n      token: match[0],\n      baseToken,\n      baseGuesses: 0,\n      repeatCount: match[0].length / baseToken.length\n    };\n    if (baseGuesses instanceof Promise) {\n      return baseGuesses.then(resolvedBaseGuesses => {\n        return {\n          ...baseMatch,\n          baseGuesses: resolvedBaseGuesses\n        };\n      });\n    }\n    return {\n      ...baseMatch,\n      baseGuesses\n    };\n  }\n  getGreedyMatch(password, lastIndex) {\n    const greedy = /(.+)\\1+/g;\n    greedy.lastIndex = lastIndex;\n    return greedy.exec(password);\n  }\n  getLazyMatch(password, lastIndex) {\n    const lazy = /(.+?)\\1+/g;\n    lazy.lastIndex = lastIndex;\n    return lazy.exec(password);\n  }\n  setMatchToken(greedyMatch, lazyMatch) {\n    const lazyAnchored = /^(.+?)\\1+$/;\n    let match;\n    let baseToken = '';\n    if (lazyMatch && greedyMatch[0].length > lazyMatch[0].length) {\n      // greedy beats lazy for 'aabaab'\n      // greedy: [aabaab, aab]\n      // lazy:   [aa,     a]\n      match = greedyMatch;\n      // greedy's repeated string might itself be repeated, eg.\n      // aabaab in aabaabaabaab.\n      // run an anchored lazy match on greedy's repeated string\n      // to find the shortest repeated string\n      const temp = lazyAnchored.exec(match[0]);\n      if (temp) {\n        baseToken = temp[1];\n      }\n    } else {\n      // lazy beats greedy for 'aaaaa'\n      // greedy: [aaaa,  aa]\n      // lazy:   [aaaaa, a]\n      match = lazyMatch;\n      if (match) {\n        baseToken = match[1];\n      }\n    }\n    return {\n      match,\n      baseToken\n    };\n  }\n  getBaseGuesses(baseToken, omniMatch) {\n    const matches = omniMatch.match(baseToken);\n    if (matches instanceof Promise) {\n      return matches.then(resolvedMatches => {\n        const baseAnalysis = scoring.mostGuessableMatchSequence(baseToken, resolvedMatches);\n        return baseAnalysis.guesses;\n      });\n    }\n    const baseAnalysis = scoring.mostGuessableMatchSequence(baseToken, matches);\n    return baseAnalysis.guesses;\n  }\n}\nexport { MatchRepeat as default };\n","import { ALL_LOWER, ALL_UPPER, ALL_DIGIT } from '../../data/const.esm.js';\n\n/*\n *-------------------------------------------------------------------------------\n * sequences (abcdef) ------------------------------\n *-------------------------------------------------------------------------------\n */\nclass MatchSequence {\n  constructor() {\n    this.MAX_DELTA = 5;\n  }\n  // eslint-disable-next-line max-statements\n  match({\n    password\n  }) {\n    /*\n     * Identifies sequences by looking for repeated differences in unicode codepoint.\n     * this allows skipping, such as 9753, and also matches some extended unicode sequences\n     * such as Greek and Cyrillic alphabets.\n     *\n     * for example, consider the input 'abcdb975zy'\n     *\n     * password: a   b   c   d   b    9   7   5   z   y\n     * index:    0   1   2   3   4    5   6   7   8   9\n     * delta:      1   1   1  -2  -41  -2  -2  69   1\n     *\n     * expected result:\n     * [(i, j, delta), ...] = [(0, 3, 1), (5, 7, -2), (8, 9, 1)]\n     */\n    const result = [];\n    if (password.length === 1) {\n      return [];\n    }\n    let i = 0;\n    let lastDelta = null;\n    const passwordLength = password.length;\n    for (let k = 1; k < passwordLength; k += 1) {\n      const delta = password.charCodeAt(k) - password.charCodeAt(k - 1);\n      if (lastDelta == null) {\n        lastDelta = delta;\n      }\n      if (delta !== lastDelta) {\n        const j = k - 1;\n        this.update({\n          i,\n          j,\n          delta: lastDelta,\n          password,\n          result\n        });\n        i = j;\n        lastDelta = delta;\n      }\n    }\n    this.update({\n      i,\n      j: passwordLength - 1,\n      delta: lastDelta,\n      password,\n      result\n    });\n    return result;\n  }\n  update({\n    i,\n    j,\n    delta,\n    password,\n    result\n  }) {\n    if (j - i > 1 || Math.abs(delta) === 1) {\n      const absoluteDelta = Math.abs(delta);\n      if (absoluteDelta > 0 && absoluteDelta <= this.MAX_DELTA) {\n        const token = password.slice(i, +j + 1 || 9e9);\n        const {\n          sequenceName,\n          sequenceSpace\n        } = this.getSequence(token);\n        return result.push({\n          pattern: 'sequence',\n          i,\n          j,\n          token: password.slice(i, +j + 1 || 9e9),\n          sequenceName,\n          sequenceSpace,\n          ascending: delta > 0\n        });\n      }\n    }\n    return null;\n  }\n  getSequence(token) {\n    // TODO conservatively stick with roman alphabet size.\n    //  (this could be improved)\n    let sequenceName = 'unicode';\n    let sequenceSpace = 26;\n    if (ALL_LOWER.test(token)) {\n      sequenceName = 'lower';\n      sequenceSpace = 26;\n    } else if (ALL_UPPER.test(token)) {\n      sequenceName = 'upper';\n      sequenceSpace = 26;\n    } else if (ALL_DIGIT.test(token)) {\n      sequenceName = 'digits';\n      sequenceSpace = 10;\n    }\n    return {\n      sequenceName,\n      sequenceSpace\n    };\n  }\n}\nexport { MatchSequence as default };\n","import { extend, sorted } from '../../helper.esm.js';\nimport { zxcvbnOptions } from '../../Options.esm.js';\n\n/*\n * ------------------------------------------------------------------------------\n * spatial match (qwerty/dvorak/keypad and so on) -----------------------------------------\n * ------------------------------------------------------------------------------\n */\nclass MatchSpatial {\n  constructor() {\n    this.SHIFTED_RX = /[~!@#$%^&*()_+QWERTYUIOP{}|ASDFGHJKL:\"ZXCVBNM<>?]/;\n  }\n  match({\n    password\n  }) {\n    const matches = [];\n    Object.keys(zxcvbnOptions.graphs).forEach(graphName => {\n      const graph = zxcvbnOptions.graphs[graphName];\n      extend(matches, this.helper(password, graph, graphName));\n    });\n    return sorted(matches);\n  }\n  checkIfShifted(graphName, password, index) {\n    if (!graphName.includes('keypad') &&\n    // initial character is shifted\n    this.SHIFTED_RX.test(password.charAt(index))) {\n      return 1;\n    }\n    return 0;\n  }\n  // eslint-disable-next-line complexity, max-statements\n  helper(password, graph, graphName) {\n    let shiftedCount;\n    const matches = [];\n    let i = 0;\n    const passwordLength = password.length;\n    while (i < passwordLength - 1) {\n      let j = i + 1;\n      let lastDirection = null;\n      let turns = 0;\n      shiftedCount = this.checkIfShifted(graphName, password, i);\n      // eslint-disable-next-line no-constant-condition\n      while (true) {\n        const prevChar = password.charAt(j - 1);\n        const adjacents = graph[prevChar] || [];\n        let found = false;\n        let foundDirection = -1;\n        let curDirection = -1;\n        // consider growing pattern by one character if j hasn't gone over the edge.\n        if (j < passwordLength) {\n          const curChar = password.charAt(j);\n          const adjacentsLength = adjacents.length;\n          for (let k = 0; k < adjacentsLength; k += 1) {\n            const adjacent = adjacents[k];\n            curDirection += 1;\n            // eslint-disable-next-line max-depth\n            if (adjacent) {\n              const adjacentIndex = adjacent.indexOf(curChar);\n              // eslint-disable-next-line max-depth\n              if (adjacentIndex !== -1) {\n                found = true;\n                foundDirection = curDirection;\n                // eslint-disable-next-line max-depth\n                if (adjacentIndex === 1) {\n                  // # index 1 in the adjacency means the key is shifted,\n                  // # 0 means unshifted: A vs a, % vs 5, etc.\n                  // # for example, 'q' is adjacent to the entry '2@'.\n                  // # @ is shifted w/ index 1, 2 is unshifted.\n                  shiftedCount += 1;\n                }\n                // eslint-disable-next-line max-depth\n                if (lastDirection !== foundDirection) {\n                  // # adding a turn is correct even in the initial\n                  // case when last_direction is null:\n                  // # every spatial pattern starts with a turn.\n                  turns += 1;\n                  lastDirection = foundDirection;\n                }\n                break;\n              }\n            }\n          }\n        }\n        // if the current pattern continued, extend j and try to grow again\n        if (found) {\n          j += 1;\n          // otherwise push the pattern discovered so far, if any...\n        } else {\n          // don't consider length 1 or 2 chains.\n          if (j - i > 2) {\n            matches.push({\n              pattern: 'spatial',\n              i,\n              j: j - 1,\n              token: password.slice(i, j),\n              graph: graphName,\n              turns,\n              shiftedCount\n            });\n          }\n          // ...and then start a new search for the rest of the password.\n          i = j;\n          break;\n        }\n      }\n    }\n    return matches;\n  }\n}\nexport { MatchSpatial as default };\n","import { SEPERATOR_CHARS } from '../../data/const.esm.js';\nconst separatorRegex = new RegExp(`[${SEPERATOR_CHARS.join('')}]`);\n/*\n *-------------------------------------------------------------------------------\n * separators (any semi-repeated special character) -----------------------------\n *-------------------------------------------------------------------------------\n */\nclass MatchSeparator {\n  static getMostUsedSeparatorChar(password) {\n    const mostUsedSeperators = [...password.split('').filter(c => separatorRegex.test(c)).reduce((memo, c) => {\n      const m = memo.get(c);\n      if (m) {\n        memo.set(c, m + 1);\n      } else {\n        memo.set(c, 1);\n      }\n      return memo;\n    }, new Map()).entries()].sort(([_a, a], [_b, b]) => b - a);\n    if (!mostUsedSeperators.length) return undefined;\n    const match = mostUsedSeperators[0];\n    // If the special character is only used once, don't treat it like a separator\n    if (match[1] < 2) return undefined;\n    return match[0];\n  }\n  static getSeparatorRegex(separator) {\n    return new RegExp(`([^${separator}\\n])(${separator})(?!${separator})`, 'g');\n    // negative lookbehind can be added again in a few years when it is more supported by the browsers (currently 2023)\n    // https://github.com/zxcvbn-ts/zxcvbn/issues/202\n    // return new RegExp(`(?<!${separator})(${separator})(?!${separator})`, 'g')\n  }\n  // eslint-disable-next-line max-statements\n  match({\n    password\n  }) {\n    const result = [];\n    if (password.length === 0) return result;\n    const mostUsedSpecial = MatchSeparator.getMostUsedSeparatorChar(password);\n    if (mostUsedSpecial === undefined) return result;\n    const isSeparator = MatchSeparator.getSeparatorRegex(mostUsedSpecial);\n    // eslint-disable-next-line no-restricted-syntax\n    for (const match of password.matchAll(isSeparator)) {\n      // eslint-disable-next-line no-continue\n      if (match.index === undefined) continue;\n      // add one to the index because we changed the regex from negative lookbehind to something simple.\n      // this simple approach uses the first character before the separater too but we only need the index of the separater\n      // https://github.com/zxcvbn-ts/zxcvbn/issues/202\n      const i = match.index + 1;\n      result.push({\n        pattern: 'separator',\n        token: mostUsedSpecial,\n        i,\n        j: i\n      });\n    }\n    return result;\n  }\n}\nexport { MatchSeparator as default };\n","import { extend, sorted } from './helper.esm.js';\nimport MatchDate from './matcher/date/matching.esm.js';\nimport MatchDictionary from './matcher/dictionary/matching.esm.js';\nimport MatchRegex from './matcher/regex/matching.esm.js';\nimport MatchRepeat from './matcher/repeat/matching.esm.js';\nimport MatchSequence from './matcher/sequence/matching.esm.js';\nimport MatchSpatial from './matcher/spatial/matching.esm.js';\nimport MatchSeparator from './matcher/separator/matching.esm.js';\nimport { zxcvbnOptions } from './Options.esm.js';\nclass Matching {\n  constructor() {\n    this.matchers = {\n      date: MatchDate,\n      dictionary: MatchDictionary,\n      regex: MatchRegex,\n      // @ts-ignore => TODO resolve this type issue. This is because it is possible to be async\n      repeat: MatchRepeat,\n      sequence: MatchSequence,\n      spatial: MatchSpatial,\n      separator: MatchSeparator\n    };\n  }\n  match(password) {\n    const matches = [];\n    const promises = [];\n    const matchers = [...Object.keys(this.matchers), ...Object.keys(zxcvbnOptions.matchers)];\n    matchers.forEach(key => {\n      if (!this.matchers[key] && !zxcvbnOptions.matchers[key]) {\n        return;\n      }\n      const Matcher = this.matchers[key] ? this.matchers[key] : zxcvbnOptions.matchers[key].Matching;\n      const usedMatcher = new Matcher();\n      const result = usedMatcher.match({\n        password,\n        omniMatch: this\n      });\n      if (result instanceof Promise) {\n        result.then(response => {\n          extend(matches, response);\n        });\n        promises.push(result);\n      } else {\n        extend(matches, result);\n      }\n    });\n    if (promises.length > 0) {\n      return new Promise((resolve, reject) => {\n        Promise.all(promises).then(() => {\n          resolve(sorted(matches));\n        }).catch(error => {\n          reject(error);\n        });\n      });\n    }\n    return sorted(matches);\n  }\n}\nexport { Matching as default };\n","import { zxcvbnOptions } from './Options.esm.js';\nconst SECOND = 1;\nconst MINUTE = SECOND * 60;\nconst HOUR = MINUTE * 60;\nconst DAY = HOUR * 24;\nconst MONTH = DAY * 31;\nconst YEAR = MONTH * 12;\nconst CENTURY = YEAR * 100;\nconst times = {\n  second: SECOND,\n  minute: MINUTE,\n  hour: HOUR,\n  day: DAY,\n  month: MONTH,\n  year: YEAR,\n  century: CENTURY\n};\n/*\n * -------------------------------------------------------------------------------\n *  Estimates time for an attacker ---------------------------------------------------------------\n * -------------------------------------------------------------------------------\n */\nclass TimeEstimates {\n  translate(displayStr, value) {\n    let key = displayStr;\n    if (value !== undefined && value !== 1) {\n      key += 's';\n    }\n    const {\n      timeEstimation\n    } = zxcvbnOptions.translations;\n    return timeEstimation[key].replace('{base}', `${value}`);\n  }\n  estimateAttackTimes(guesses) {\n    const crackTimesSeconds = {\n      onlineThrottling100PerHour: guesses / (100 / 3600),\n      onlineNoThrottling10PerSecond: guesses / 10,\n      offlineSlowHashing1e4PerSecond: guesses / 1e4,\n      offlineFastHashing1e10PerSecond: guesses / 1e10\n    };\n    const crackTimesDisplay = {\n      onlineThrottling100PerHour: '',\n      onlineNoThrottling10PerSecond: '',\n      offlineSlowHashing1e4PerSecond: '',\n      offlineFastHashing1e10PerSecond: ''\n    };\n    Object.keys(crackTimesSeconds).forEach(scenario => {\n      const seconds = crackTimesSeconds[scenario];\n      crackTimesDisplay[scenario] = this.displayTime(seconds);\n    });\n    return {\n      crackTimesSeconds,\n      crackTimesDisplay,\n      score: this.guessesToScore(guesses)\n    };\n  }\n  guessesToScore(guesses) {\n    const DELTA = 5;\n    if (guesses < 1e3 + DELTA) {\n      // risky password: \"too guessable\"\n      return 0;\n    }\n    if (guesses < 1e6 + DELTA) {\n      // modest protection from throttled online attacks: \"very guessable\"\n      return 1;\n    }\n    if (guesses < 1e8 + DELTA) {\n      // modest protection from unthrottled online attacks: \"somewhat guessable\"\n      return 2;\n    }\n    if (guesses < 1e10 + DELTA) {\n      // modest protection from offline attacks: \"safely unguessable\"\n      // assuming a salted, slow hash function like bcrypt, scrypt, PBKDF2, argon, etc\n      return 3;\n    }\n    // strong protection from offline attacks under same scenario: \"very unguessable\"\n    return 4;\n  }\n  displayTime(seconds) {\n    let displayStr = 'centuries';\n    let base;\n    const timeKeys = Object.keys(times);\n    const foundIndex = timeKeys.findIndex(time => seconds < times[time]);\n    if (foundIndex > -1) {\n      displayStr = timeKeys[foundIndex - 1];\n      if (foundIndex !== 0) {\n        base = Math.round(seconds / times[displayStr]);\n      } else {\n        displayStr = 'ltSecond';\n      }\n    }\n    return this.translate(displayStr, base);\n  }\n}\nexport { TimeEstimates as default };\n","var bruteforceMatcher = () => {\n  return null;\n};\nexport { bruteforceMatcher as default };\n","import { zxcvbnOptions } from '../../Options.esm.js';\nvar dateMatcher = () => {\n  return {\n    warning: zxcvbnOptions.translations.warnings.dates,\n    suggestions: [zxcvbnOptions.translations.suggestions.dates]\n  };\n};\nexport { dateMatcher as default };\n","import { zxcvbnOptions } from '../../Options.esm.js';\nimport { START_UPPER, ALL_UPPER_INVERTED } from '../../data/const.esm.js';\nconst getDictionaryWarningPassword = (match, isSoleMatch) => {\n  let warning = null;\n  if (isSoleMatch && !match.l33t && !match.reversed) {\n    if (match.rank <= 10) {\n      warning = zxcvbnOptions.translations.warnings.topTen;\n    } else if (match.rank <= 100) {\n      warning = zxcvbnOptions.translations.warnings.topHundred;\n    } else {\n      warning = zxcvbnOptions.translations.warnings.common;\n    }\n  } else if (match.guessesLog10 <= 4) {\n    warning = zxcvbnOptions.translations.warnings.similarToCommon;\n  }\n  return warning;\n};\nconst getDictionaryWarningWikipedia = (match, isSoleMatch) => {\n  let warning = null;\n  if (isSoleMatch) {\n    warning = zxcvbnOptions.translations.warnings.wordByItself;\n  }\n  return warning;\n};\nconst getDictionaryWarningNames = (match, isSoleMatch) => {\n  if (isSoleMatch) {\n    return zxcvbnOptions.translations.warnings.namesByThemselves;\n  }\n  return zxcvbnOptions.translations.warnings.commonNames;\n};\nconst getDictionaryWarning = (match, isSoleMatch) => {\n  let warning = null;\n  const dictName = match.dictionaryName;\n  const isAName = dictName === 'lastnames' || dictName.toLowerCase().includes('firstnames');\n  if (dictName === 'passwords') {\n    warning = getDictionaryWarningPassword(match, isSoleMatch);\n  } else if (dictName.includes('wikipedia')) {\n    warning = getDictionaryWarningWikipedia(match, isSoleMatch);\n  } else if (isAName) {\n    warning = getDictionaryWarningNames(match, isSoleMatch);\n  } else if (dictName === 'userInputs') {\n    warning = zxcvbnOptions.translations.warnings.userInputs;\n  }\n  return warning;\n};\nvar dictionaryMatcher = (match, isSoleMatch) => {\n  const warning = getDictionaryWarning(match, isSoleMatch);\n  const suggestions = [];\n  const word = match.token;\n  if (word.match(START_UPPER)) {\n    suggestions.push(zxcvbnOptions.translations.suggestions.capitalization);\n  } else if (word.match(ALL_UPPER_INVERTED) && word.toLowerCase() !== word) {\n    suggestions.push(zxcvbnOptions.translations.suggestions.allUppercase);\n  }\n  if (match.reversed && match.token.length >= 4) {\n    suggestions.push(zxcvbnOptions.translations.suggestions.reverseWords);\n  }\n  if (match.l33t) {\n    suggestions.push(zxcvbnOptions.translations.suggestions.l33t);\n  }\n  return {\n    warning,\n    suggestions\n  };\n};\nexport { dictionaryMatcher as default };\n","import { zxcvbnOptions } from '../../Options.esm.js';\nvar regexMatcher = match => {\n  if (match.regexName === 'recentYear') {\n    return {\n      warning: zxcvbnOptions.translations.warnings.recentYears,\n      suggestions: [zxcvbnOptions.translations.suggestions.recentYears, zxcvbnOptions.translations.suggestions.associatedYears]\n    };\n  }\n  return {\n    warning: null,\n    suggestions: []\n  };\n};\nexport { regexMatcher as default };\n","import { zxcvbnOptions } from '../../Options.esm.js';\nvar repeatMatcher = match => {\n  let warning = zxcvbnOptions.translations.warnings.extendedRepeat;\n  if (match.baseToken.length === 1) {\n    warning = zxcvbnOptions.translations.warnings.simpleRepeat;\n  }\n  return {\n    warning,\n    suggestions: [zxcvbnOptions.translations.suggestions.repeated]\n  };\n};\nexport { repeatMatcher as default };\n","import { zxcvbnOptions } from '../../Options.esm.js';\nvar sequenceMatcher = () => {\n  return {\n    warning: zxcvbnOptions.translations.warnings.sequences,\n    suggestions: [zxcvbnOptions.translations.suggestions.sequences]\n  };\n};\nexport { sequenceMatcher as default };\n","import { zxcvbnOptions } from '../../Options.esm.js';\nvar spatialMatcher = match => {\n  let warning = zxcvbnOptions.translations.warnings.keyPattern;\n  if (match.turns === 1) {\n    warning = zxcvbnOptions.translations.warnings.straightRow;\n  }\n  return {\n    warning,\n    suggestions: [zxcvbnOptions.translations.suggestions.longerKeyboardPattern]\n  };\n};\nexport { spatialMatcher as default };\n","var separatorMatcher = () => {\n  // no suggestions\n  return null;\n};\nexport { separatorMatcher as default };\n","import { zxcvbnOptions } from './Options.esm.js';\nimport bruteforceMatcher from './matcher/bruteforce/feedback.esm.js';\nimport dateMatcher from './matcher/date/feedback.esm.js';\nimport dictionaryMatcher from './matcher/dictionary/feedback.esm.js';\nimport regexMatcher from './matcher/regex/feedback.esm.js';\nimport repeatMatcher from './matcher/repeat/feedback.esm.js';\nimport sequenceMatcher from './matcher/sequence/feedback.esm.js';\nimport spatialMatcher from './matcher/spatial/feedback.esm.js';\nimport separatorMatcher from './matcher/separator/feedback.esm.js';\nconst defaultFeedback = {\n  warning: null,\n  suggestions: []\n};\n/*\n * -------------------------------------------------------------------------------\n *  Generate feedback ---------------------------------------------------------------\n * -------------------------------------------------------------------------------\n */\nclass Feedback {\n  constructor() {\n    this.matchers = {\n      bruteforce: bruteforceMatcher,\n      date: dateMatcher,\n      dictionary: dictionaryMatcher,\n      regex: regexMatcher,\n      repeat: repeatMatcher,\n      sequence: sequenceMatcher,\n      spatial: spatialMatcher,\n      separator: separatorMatcher\n    };\n    this.defaultFeedback = {\n      warning: null,\n      suggestions: []\n    };\n    this.setDefaultSuggestions();\n  }\n  setDefaultSuggestions() {\n    this.defaultFeedback.suggestions.push(zxcvbnOptions.translations.suggestions.useWords, zxcvbnOptions.translations.suggestions.noNeed);\n  }\n  getFeedback(score, sequence) {\n    if (sequence.length === 0) {\n      return this.defaultFeedback;\n    }\n    if (score > 2) {\n      return defaultFeedback;\n    }\n    const extraFeedback = zxcvbnOptions.translations.suggestions.anotherWord;\n    const longestMatch = this.getLongestMatch(sequence);\n    let feedback = this.getMatchFeedback(longestMatch, sequence.length === 1);\n    if (feedback !== null && feedback !== undefined) {\n      feedback.suggestions.unshift(extraFeedback);\n    } else {\n      feedback = {\n        warning: null,\n        suggestions: [extraFeedback]\n      };\n    }\n    return feedback;\n  }\n  getLongestMatch(sequence) {\n    let longestMatch = sequence[0];\n    const slicedSequence = sequence.slice(1);\n    slicedSequence.forEach(match => {\n      if (match.token.length > longestMatch.token.length) {\n        longestMatch = match;\n      }\n    });\n    return longestMatch;\n  }\n  getMatchFeedback(match, isSoleMatch) {\n    if (this.matchers[match.pattern]) {\n      return this.matchers[match.pattern](match, isSoleMatch);\n    }\n    if (zxcvbnOptions.matchers[match.pattern] && 'feedback' in zxcvbnOptions.matchers[match.pattern]) {\n      return zxcvbnOptions.matchers[match.pattern].feedback(match, isSoleMatch);\n    }\n    return defaultFeedback;\n  }\n}\nexport { Feedback as default };\n","import Matching from './Matching.esm.js';\nimport scoring from './scoring/index.esm.js';\nimport TimeEstimates from './TimeEstimates.esm.js';\nimport Feedback from './Feedback.esm.js';\nimport { zxcvbnOptions } from './Options.esm.js';\nexport { Options } from './Options.esm.js';\nexport { default as debounce } from './debounce.esm.js';\nconst time = () => new Date().getTime();\nconst createReturnValue = (resolvedMatches, password, start) => {\n  const feedback = new Feedback();\n  const timeEstimates = new TimeEstimates();\n  const matchSequence = scoring.mostGuessableMatchSequence(password, resolvedMatches);\n  const calcTime = time() - start;\n  const attackTimes = timeEstimates.estimateAttackTimes(matchSequence.guesses);\n  return {\n    calcTime,\n    ...matchSequence,\n    ...attackTimes,\n    feedback: feedback.getFeedback(attackTimes.score, matchSequence.sequence)\n  };\n};\nconst main = (password, userInputs) => {\n  if (userInputs) {\n    zxcvbnOptions.extendUserInputsDictionary(userInputs);\n  }\n  const matching = new Matching();\n  return matching.match(password);\n};\nconst zxcvbn = (password, userInputs) => {\n  const start = time();\n  const matches = main(password, userInputs);\n  if (matches instanceof Promise) {\n    throw new Error('You are using a Promised matcher, please use `zxcvbnAsync` for it.');\n  }\n  return createReturnValue(matches, password, start);\n};\nconst zxcvbnAsync = async (password, userInputs) => {\n  const usedPassword = password.substring(0, zxcvbnOptions.maxLength);\n  const start = time();\n  const matches = await main(usedPassword, userInputs);\n  return createReturnValue(matches, usedPassword, start);\n};\nexport { zxcvbn, zxcvbnAsync, zxcvbnOptions };\n","import { ChangeDetectionStrategy, Component, EventEmitter, Input, OnChanges, OnInit, Output, SimpleChange } from '@angular/core'\nimport { ZxcvbnResult, zxcvbn, zxcvbnOptions } from '@zxcvbn-ts/core'\n\n@Component({\n  selector: 'app-password-strength',\n  standalone: true,\n  imports: [],\n  templateUrl: './password-strength.component.html',\n  styleUrl: './password-strength.component.scss',\n  changeDetection: ChangeDetectionStrategy.OnPush\n})\nexport class PasswordStrengthComponent implements OnChanges, OnInit {\n\n  @Input() public passwordToCheck: string = ''\n  @Output() passwordStrength = new EventEmitter<boolean>()\n\n\n  bar0: string = ''\n  bar1: string = ''\n  bar2: string = ''\n  bar3: string = ''\n\n\n  private colors = ['darkred', 'orangered', 'orange', 'yellowgreen', 'green']\n\n  message: string = ''\n  warning: string = ''\n  messageColor: string = ''\n\n  async loadOptions() {\n    const zxcvbnCommonPackage = await import(\n      /* webpackChunkName: \"zxcvbnCommonPackage\" */ '@zxcvbn-ts/language-common'\n    )\n    const zxcvbnEnPackage = await import(\n      /* webpackChunkName: \"zxcvbnEnPackage\" */ '@zxcvbn-ts/language-en'\n    )\n\n    return {\n      translations: zxcvbnEnPackage.translations,\n      graphs: zxcvbnCommonPackage.adjacencyGraphs,\n      dictionary: {\n        ...zxcvbnCommonPackage.dictionary,\n        ...zxcvbnEnPackage.dictionary,\n      },\n    }\n\n  }\n\n  async ngOnInit(): Promise<void> {\n    await this.loadOptions()\n  }\n\n  async checkStrength(password: string) : Promise<ZxcvbnResult> {\n    zxcvbnOptions.setOptions(await this.loadOptions())\n    return zxcvbn(password)\n  }\n\n  async ngOnChanges(changes: { [propName: string]: SimpleChange }): Promise<void> {\n    const password = changes['passwordToCheck'].currentValue\n\n    this.setBarColors(4, '#DDD')\n\n    if (password) {\n      const pwdStrength: ZxcvbnResult = await this.checkStrength(password)\n      pwdStrength.score === 4 ? this.passwordStrength.emit(true) : this.passwordStrength.emit(false)\n\n      const color = this.getColor(pwdStrength.score)\n      this.setBarColors(color.index, color.color)\n\n\n      switch (pwdStrength.score) {\n        case 0:\n        case 1:\n          this.message = 'Poor'\n          break\n        case 2:\n          this.message = 'Not Good'\n          break\n        case 3:\n          this.message = 'Average'\n          break\n        case 4:\n          this.message = 'Good'\n          break\n      }\n      this.warning = pwdStrength.feedback.warning ?? ''\n    } else {\n      this.message = ''\n    }\n  }\n\n  private getColor(strength: number) {\n\n    this.messageColor = this.colors[strength]\n\n    return {\n      index: strength + 1,\n      color: this.colors[strength],\n    }\n  }\n\n  private setBarColors(count: number, color: string) {\n    for (let n = 0; n < count; n++) {\n      (this as any)['bar' + n] = color\n    }\n  }\n}\n","<div class=\"strength\">\n    <ul class=\"strengthBar mt-2\">\n        <li class=\"point\" [style.background-color]=\"bar0\"></li>\n        <li class=\"point\" [style.background-color]=\"bar1\"></li>\n        <li class=\"point\" [style.background-color]=\"bar2\"></li>\n        <li class=\"point\" [style.background-color]=\"bar3\"></li>\n    </ul>\n\n    @if (passwordToCheck.length) {\n        <p class=\"text-center mb-0\" [style.color]=\"messageColor\">{{ message }}</p>\n    }\n</div>\n<p class=\"text-center mb-0\">&nbsp;{{ warning }}</p>\n"],"names":["SiteSearchService","searchToShow","Subject","searchToShow$","asObservable","constructor","loadSearch","search","next","factory","ɵfac","providedIn","extend","listToExtend","list","sorted","matches","m1","m2","buildRankedDictionary","orderedList","result","counter","word","dateSplits","DATE_MAX_YEAR","DATE_MIN_YEAR","DATE_SPLITS","dateSplits","BRUTEFORCE_CARDINALITY","MIN_GUESSES_BEFORE_GROWING_SEQUENCE","MIN_SUBMATCH_GUESSES_SINGLE_CHAR","MIN_SUBMATCH_GUESSES_MULTI_CHAR","MIN_YEAR_SPACE","START_UPPER","END_UPPER","ALL_UPPER","ALL_UPPER_INVERTED","ALL_LOWER","ALL_LOWER_INVERTED","ONE_LOWER","ONE_UPPER","ALPHA_INVERTED","ALL_DIGIT","REFERENCE_YEAR","REGEXEN","SEPERATOR_CHARS","SEPERATOR_CHAR_COUNT","MatchDate","password","matches","filteredMatches","sorted","maybeDateWithSeparator","i","j","token","regexMatch","dmy","maybeDateNoSeparator","metric","candidate","REFERENCE_YEAR","candidates","index","DATE_SPLITS","k","l","bestCandidate","minDistance","distance","match","isSubmatch","matchesLength","otherMatch","integers","over12","over31","under1","len1","int","DATE_MIN_YEAR","DATE_MAX_YEAR","possibleYearSplits","possibleYearSplitsLength","y","rest","dm","temp","data","day","month","year","peq","myers_32","a","b","n","m","lst","pv","mv","sc","i","eq","xv","myers_x","mhc","phc","hsize","vsize","j","start","vlen","k","pb","mb","xh","ph","mh","score","distance","tmp","getUsedThreshold","password","entry","threshold","isPasswordToShort","isThresholdLongerThanPassword","findLevenshteinDistance","rankedDictionary","foundDistance","found","usedThreshold","foundEntryDistance","distance","isInThreshold","l33tTable","translationKeys","TrieNode","_TrieNode","parents","key","subs","firstChar","cur","i","c","child","l33tTableToTrieNode","l33tTable","triNode","letter","substitutions","substitution","Options","l33tTable","l33tTableToTrieNode","TrieNode","translationKeys","options","translations","valid","type","translationType","key","rankedDictionaries","rankedDictionariesMaxWorkSize","name","buildRankedDictionary","list","data","el","a","b","sanitizedInputs","input","inputType","dictionary","newList","matcher","zxcvbnOptions","MatchReverse","defaultMatch","password","passwordReversed","match","__spreadProps","__spreadValues","CleanPasswords","substr","limit","trieRoot","index","nodes","cur","i","character","onlyFullSub","isFullSub","subIndex","changes","lastSubLetter","consecutiveSubCount","hasSubs","subs","sub","newSubs","firstChar","getCleanPasswords","password","getExtras","passwordWithSubs","i","j","iUnsubbed","changes","value","change","usedChanges","jUnsubbed","filtered","subDisplay","t","MatchL33t","defaultMatch","matches","newMatch","l33tMatch","key","password","subbedPasswords","getCleanPasswords","zxcvbnOptions","hasFullMatch","isFullSubstitution","subbedPassword","matchedDictionary","match","extras","token","__spreadValues","__spreadProps","alreadyIncluded","MatchDictionary","MatchL33t","MatchReverse","password","matches","sorted","useLevenshtein","passwordLength","passwordLower","zxcvbnOptions","dictionaryName","rankedDict","longestDictionaryWordSize","searchWidth","i","searchEnd","j","usedPassword","isInDictionary","foundLevenshteinDistance","isFullPassword","findLevenshteinDistance","isLevenshteinMatch","usedRankPassword","rank","__spreadValues","MatchRegex","password","regexes","REGEXEN","matches","name","regex","regexMatch","token","sorted","utils","n","k","count","coEff","i","num","rval","bruteforceMatcher","token","guesses","BRUTEFORCE_CARDINALITY","minGuesses","MIN_SUBMATCH_GUESSES_SINGLE_CHAR","MIN_SUBMATCH_GUESSES_MULTI_CHAR","dateMatcher","year","separator","guesses","REFERENCE_YEAR","MIN_YEAR_SPACE","getVariations","cleanedWord","wordArray","upperCaseCount","char","ONE_UPPER","lowerCaseCount","ONE_LOWER","variations","variationLength","utils","uppercaseVariant","word","ALPHA_INVERTED","ALL_LOWER_INVERTED","commonCases","START_UPPER","END_UPPER","ALL_UPPER_INVERTED","commonCasesLength","i","regex","countSubstring","string","substring","count","pos","getCounts","sub","token","tokenLower","subbedCount","unsubbedCount","l33tVariant","l33t","subs","variations","p","possibilities","i","utils","dictionaryMatcher","rank","reversed","l33t","subs","token","dictionaryName","baseGuesses","uppercaseVariations","uppercaseVariant","l33tVariations","l33tVariant","reversedVariations","calculation","regexMatcher","regexName","regexMatch","token","charClassBases","REFERENCE_YEAR","MIN_YEAR_SPACE","repeatMatcher","baseGuesses","repeatCount","sequenceMatcher","token","ascending","firstChr","baseGuesses","calcAverageDegree","graph","average","key","neighbors","entry","estimatePossiblePatterns","token","turns","startingPosition","zxcvbnOptions","averageDegree","guesses","tokenLength","i","possibleTurns","j","utils","spatialMatcher","shiftedCount","unShiftedCount","shiftedVariations","separatorMatcher","SEPERATOR_CHAR_COUNT","getMinGuesses","match","password","minGuesses","MIN_SUBMATCH_GUESSES_SINGLE_CHAR","MIN_SUBMATCH_GUESSES_MULTI_CHAR","matchers","bruteforceMatcher","dateMatcher","dictionaryMatcher","regexMatcher","repeatMatcher","sequenceMatcher","spatialMatcher","separatorMatcher","getScoring","name","zxcvbnOptions","estimateGuesses","extraData","estimationResult","guesses","matchGuesses","__spreadProps","__spreadValues","utils","scoringHelper","size","valueType","result","i","value","j","match","sequenceLength","k","estimatedMatch","estimateGuesses","pi","g","utils","MIN_GUESSES_BEFORE_GROWING_SEQUENCE","shouldSkip","competingPatternLength","competingMetricMatch","passwordCharIndex","tmp","passwordLength","optimalMatchSequence","temp","candidateSequenceLength","candidateMetricMatch","scoring","password","matches","excludeAdditive","matchesByCoordinateJ","m1","m2","optimalSequenceLength","guesses","MatchRepeat","password","omniMatch","matches","lastIndex","greedyMatch","lazyMatch","match","baseToken","j","baseGuesses","baseMatch","resolvedBaseGuesses","__spreadProps","__spreadValues","greedy","lazy","lazyAnchored","temp","resolvedMatches","scoring","MatchSequence","password","result","i","lastDelta","passwordLength","k","delta","j","absoluteDelta","token","sequenceName","sequenceSpace","ALL_LOWER","ALL_UPPER","ALL_DIGIT","MatchSpatial","password","matches","zxcvbnOptions","graphName","graph","extend","sorted","index","shiftedCount","passwordLength","j","lastDirection","turns","prevChar","adjacents","found","foundDirection","curDirection","curChar","adjacentsLength","k","adjacent","adjacentIndex","separatorRegex","SEPERATOR_CHARS","MatchSeparator","_MatchSeparator","password","mostUsedSeperators","c","memo","m","_a","a","_b","b","match","separator","result","mostUsedSpecial","isSeparator","Matching","MatchDate","MatchDictionary","MatchRegex","MatchRepeat","MatchSequence","MatchSpatial","MatchSeparator","password","matches","promises","zxcvbnOptions","key","Matcher","result","response","extend","resolve","reject","sorted","error","SECOND","MINUTE","HOUR","DAY","MONTH","YEAR","CENTURY","times","TimeEstimates","displayStr","value","key","timeEstimation","zxcvbnOptions","guesses","crackTimesSeconds","crackTimesDisplay","scenario","seconds","base","timeKeys","foundIndex","time","bruteforceMatcher","dateMatcher","zxcvbnOptions","getDictionaryWarningPassword","match","isSoleMatch","warning","zxcvbnOptions","getDictionaryWarningWikipedia","getDictionaryWarningNames","getDictionaryWarning","dictName","isAName","dictionaryMatcher","suggestions","word","START_UPPER","ALL_UPPER_INVERTED","regexMatcher","match","zxcvbnOptions","repeatMatcher","match","warning","zxcvbnOptions","sequenceMatcher","zxcvbnOptions","spatialMatcher","match","warning","zxcvbnOptions","separatorMatcher","defaultFeedback","Feedback","bruteforceMatcher","dateMatcher","dictionaryMatcher","regexMatcher","repeatMatcher","sequenceMatcher","spatialMatcher","separatorMatcher","zxcvbnOptions","score","sequence","extraFeedback","longestMatch","feedback","match","isSoleMatch","time","createReturnValue","resolvedMatches","password","start","feedback","Feedback","timeEstimates","TimeEstimates","matchSequence","scoring","calcTime","attackTimes","__spreadProps","__spreadValues","main","userInputs","zxcvbnOptions","Matching","zxcvbn","matches","ɵɵelementStart","ɵɵtext","ɵɵelementEnd","ɵɵstyleProp","ctx_r0","messageColor","ɵɵadvance","ɵɵtextInterpolate","message","PasswordStrengthComponent","passwordToCheck","passwordStrength","EventEmitter","bar0","bar1","bar2","bar3","colors","warning","loadOptions","__async","zxcvbnCommonPackage","zxcvbnEnPackage","translations","graphs","adjacencyGraphs","dictionary","__spreadValues","ngOnInit","checkStrength","password","zxcvbnOptions","setOptions","zxcvbn","ngOnChanges","changes","currentValue","setBarColors","pwdStrength","score","emit","color","getColor","index","feedback","strength","count","n","selectors","inputs","outputs","standalone","features","ɵɵNgOnChangesFeature","ɵɵStandaloneFeature","decls","vars","consts","template","rf","ctx","ɵɵelement","ɵɵtemplate","PasswordStrengthComponent_Conditional_6_Template","ɵɵconditional","length","ɵɵtextInterpolate1"],"mappings":"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","debug_id":"534ea107-5a34-5af9-8e3d-876039eaad1e"}