pub struct AttackTimes {
  crack_times_seconds : CrackTimes
  crack_times_display : CrackTimesDisplay
  score : Int
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub struct BruteforceMatch {
  i : Int
  j : Int
  token : String
  guesses : Double
  guesses_log10 : Double
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub struct CrackTimes {
  online_throttling_100_per_hour : Double
  online_no_throttling_10_per_second : Double
  offline_slow_hashing_1e4_per_second : Double
  offline_fast_hashing_1e10_per_second : Double
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub struct CrackTimesDisplay {
  online_throttling_100_per_hour : String
  online_no_throttling_10_per_second : String
  offline_slow_hashing_1e4_per_second : String
  offline_fast_hashing_1e10_per_second : String
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub struct DateMatch {
  i : Int
  j : Int
  token : String
  separator : String
  year : Int
  month : Int
  day : Int
  guesses : Double
  guesses_log10 : Double
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub enum Dictionary {
  Passwords
  English
  FemaleNames
  MaleNames
  Surnames
  UsTvAndFilm
  UserInputs
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub struct DictionaryMatch {
  i : Int
  j : Int
  token : String
  matched_word : String
  rank : Int
  dictionary_name : Dictionary
  reversed : Bool
  l33t : Bool
  sub : Array[(Char, Char)]
  guesses : Double
  guesses_log10 : Double
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub struct Entropy {
  password : String
  guesses : Double
  guesses_log10 : Double
  score : Int
  crack_times_seconds : CrackTimes
  crack_times_display : CrackTimesDisplay
  sequence : Array[Match]
  feedback : Feedback
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub struct Feedback {
  warning : String
  suggestions : Array[String]
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub enum Match {
  Bruteforce(BruteforceMatch)
  Dictionary(DictionaryMatch)
  Spatial(SpatialMatch)
  Repeat(RepeatMatch)
  Sequence(SequenceMatch)
  Regex(RegexMatch)
  Date(DateMatch)
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub struct MatchSequence {
  password : String
  guesses : Double
  guesses_log10 : Double
  sequence : Array[Match]
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub struct Omnimatcher {
  dictionaries : Array[(Dictionary, Map[String, Int])]
  max_word_length : Int
  reference_year : Int
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub struct RegexMatch {
  i : Int
  j : Int
  token : String
  regex_name : String
  guesses : Double
  guesses_log10 : Double
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub struct RepeatMatch {
  i : Int
  j : Int
  token : String
  base_token : String
  base_guesses : Double
  base_matches : Array[Match]
  repeat_count : Int
  guesses : Double
  guesses_log10 : Double
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub struct SequenceMatch {
  i : Int
  j : Int
  token : String
  sequence_name : String
  sequence_space : Int
  ascending : Bool
  guesses : Double
  guesses_log10 : Double
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub struct SpatialMatch {
  i : Int
  j : Int
  token : String
  graph : String
  turns : Int
  shifted_count : Int
  guesses : Double
  guesses_log10 : Double
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

fn all_graphs() -> Array[(String, Map[Char, Array[(Char, Char)?]])]

fn build_ranked_dict(words : Array[String]) -> Map[String, Int]

let builtin_dictionaries : Array[(Dictionary, 
@moonbitlang/core/lazy.Lazy
Lazy[Map[String, Int]])]

fn date_match(password : Array[Char], reference_year : Int) -> Array[Match]

let default_feedback : Feedback

fn dictionary_match(password : Array[Char], dictionaries : Array[(Dictionary, Map[String, Int])], max_word_length : Int) -> Array[Match]

fn dictionary_match_inner(password : Array[Char], password_lower : Array[Char], dictionaries : Array[(Dictionary, Map[String, Int])], max_word_length : Int) -> Array[Match]

fn english_wikipedia_list() -> Array[String]

fn estimate_attack_times(guesses : Double) -> AttackTimes

fn factorial(n : Int) -> Double

fn female_names_list() -> Array[String]

fn get_feedback(score : Int, sequence : Array[Match]) -> Feedback

fn get_graph(name : String) -> Map[Char, Array[(Char, Char)?]]

let graph_names : Array[String]

fn guesses_to_score(guesses : Double) -> Int

let keyboard_average_degree : Double

let keyboard_starting_positions : Int

let keypad_average_degree : Double

let keypad_starting_positions : Int

fn l33t_match(password : Array[Char], dictionaries : Array[(Dictionary, Map[String, Int])], table : Map[Char, Array[Char]], max_word_length : Int) -> Array[Match]

fn log10(n : Double) -> Double

fn log2(n : Double) -> Double

fn male_names_list() -> Array[String]

let max_dictionary_word_length : 
@moonbitlang/core/lazy.Lazy
Lazy[Int]

fn mod_impl(n : Int, m : Int) -> Int

fn most_guessable_match_sequence(password : String, matches : Array[Match], reference_year : Int, exclude_additive? : Bool) -> MatchSequence

fn nCk(n : Int, k : Int) -> Double

fn passwords_list() -> Array[String]

fn ranked_lookup(word : String) -> (Dictionary, Int)?

fn regex_match(password : Array[Char]) -> Array[Match]

fn relevant_l33t_subtable(password : Array[Char], table : Map[Char, Array[Char]]) -> Map[Char, Array[Char]]

fn repeat_match(password : Array[Char], dictionaries : Array[(Dictionary, Map[String, Int])], max_word_length : Int, table : Map[Char, Array[Char]], reference_year : Int) -> Array[Match]

fn reverse_dictionary_match(password : Array[Char], dictionaries : Array[(Dictionary, Map[String, Int])], max_word_length : Int) -> Array[Match]

fn sequence_match(password : Array[Char]) -> Array[Match]

fn sort_matches(matches : Array[Match]) -> Array[Match]

fn spatial_match(password : Array[Char], graphs : Array[(String, Map[Char, Array[(Char, Char)?]])]) -> Array[Match]

fn surnames_list() -> Array[String]

fn to_ascii_lower(chars : Array[Char]) -> Array[Char]

fn us_tv_and_film_list() -> Array[String]

fn zxcvbn(password : String, user_inputs : Array[String], reference_year? : Int) -> Entropy

fn zxcvbn_password(password : String) -> Entropy