Full Code of Automattic/harper for AI

gitextract_av__3sa_/

├── .dockerignore
├── .editorconfig
├── .envrc
├── .gitattributes
├── .github/
│   ├── ISSUE_TEMPLATE/
│   │   ├── bug_report.md
│   │   ├── report-false-positive.md
│   │   ├── report-grammatical-error.md
│   │   └── suggest-a-feature.md
│   ├── dependabot.yml
│   ├── pull_request_template.md
│   └── workflows/
│       ├── binaries.yml
│       ├── build_web.yml
│       ├── chrome_plugin.yml
│       ├── just_checks.yml
│       ├── stale.yml
│       ├── vscode_plugin.yml
│       └── wp_plugin.yml
├── .gitignore
├── .node-version
├── .npmrc
├── AGENTS.md
├── ARCHITECTURE.md
├── COMPARISON.md
├── CONTRIBUTING.md
├── Cargo.toml
├── Dockerfile
├── LICENSE
├── README.md
├── biome.json
├── demo.md
├── docker-compose.dev.yml
├── docker-compose.yml
├── flake.nix
├── fuzz/
│   ├── .gitignore
│   ├── Cargo.toml
│   ├── README.md
│   └── fuzz_targets/
│       ├── fuzz_harper_comment.rs
│       ├── fuzz_harper_core_markdown.rs
│       ├── fuzz_harper_html.rs
│       ├── fuzz_harper_literate_haskell.rs
│       └── fuzz_harper_typst.rs
├── harper-asciidoc/
│   ├── Cargo.toml
│   ├── src/
│   │   └── lib.rs
│   └── tests/
│       ├── asciidoc_tests.rs
│       └── test_sources/
│           ├── basic.adoc
│           ├── comment.adoc
│           ├── comprehensive.adoc
│           └── table.adoc
├── harper-brill/
│   ├── Cargo.toml
│   ├── finished_chunker/
│   │   ├── model.mpk
│   │   └── vocab.json
│   ├── src/
│   │   └── lib.rs
│   ├── trained_chunker_model.json
│   └── trained_tagger_model.json
├── harper-cli/
│   ├── Cargo.toml
│   ├── README.md
│   ├── src/
│   │   ├── annotate.rs
│   │   ├── input/
│   │   │   ├── multi_input.rs
│   │   │   └── single_input.rs
│   │   ├── input.rs
│   │   ├── lint.rs
│   │   └── main.rs
│   └── tests/
│       ├── no_color.rs
│       └── output_format.rs
├── harper-comments/
│   ├── Cargo.toml
│   ├── README.md
│   ├── src/
│   │   ├── comment_parser.rs
│   │   ├── comment_parsers/
│   │   │   ├── go.rs
│   │   │   ├── javadoc.rs
│   │   │   ├── jsdoc.rs
│   │   │   ├── lua.rs
│   │   │   ├── mod.rs
│   │   │   ├── solidity.rs
│   │   │   └── unit.rs
│   │   ├── lib.rs
│   │   └── masker.rs
│   └── tests/
│       ├── language_support.rs
│       └── language_support_sources/
│           ├── basic.clj
│           ├── basic_groovy.groovy
│           ├── basic_kotlin.kt
│           ├── clean.lua
│           ├── clean.ps1
│           ├── clean.rs
│           ├── clean.sol
│           ├── clean.zig
│           ├── common.mill
│           ├── complex_gradle_build.gradle
│           ├── complex_groovy_block_comments.groovy
│           ├── complex_groovy_strings_regex.groovy
│           ├── dirty.lua
│           ├── dirty.zig
│           ├── empty.js
│           ├── eof.rs
│           ├── ignore_comments.c
│           ├── ignore_comments.ps1
│           ├── ignore_comments.rs
│           ├── ignore_comments.sol
│           ├── ignore_shebang_1.sh
│           ├── ignore_shebang_2.sh
│           ├── ignore_shebang_3.sh
│           ├── ignore_shebang_4.sh
│           ├── issue_1097.lua
│           ├── issue_132.rs
│           ├── issue_229.c
│           ├── issue_229.cs
│           ├── issue_229.js
│           ├── issue_96.lua
│           ├── issue_96.rb
│           ├── javadoc_clean_simple.java
│           ├── javadoc_complex.java
│           ├── jsdoc.ts
│           ├── laravel_app.php
│           ├── merged_lines.ts
│           ├── multiline_comments.cpp
│           ├── multiline_comments.sol
│           └── multiline_comments.ts
├── harper-core/
│   ├── Cargo.toml
│   ├── README.md
│   ├── annotations.json
│   ├── benches/
│   │   ├── essay.md
│   │   └── parse_essay.rs
│   ├── build.rs
│   ├── clippy.toml
│   ├── dictionary.dict
│   ├── irregular_nouns.json
│   ├── irregular_verbs.json
│   ├── proper_noun_rules.json
│   ├── src/
│   │   ├── case.rs
│   │   ├── char_ext.rs
│   │   ├── char_string.rs
│   │   ├── currency.rs
│   │   ├── dict_word_metadata.rs
│   │   ├── dict_word_metadata_orthography.rs
│   │   ├── document.rs
│   │   ├── edit_distance.rs
│   │   ├── expr/
│   │   │   ├── all.rs
│   │   │   ├── anchor_end.rs
│   │   │   ├── anchor_start.rs
│   │   │   ├── duration_expr.rs
│   │   │   ├── expr_map.rs
│   │   │   ├── filter.rs
│   │   │   ├── first_match_of.rs
│   │   │   ├── fixed_phrase.rs
│   │   │   ├── longest_match_of.rs
│   │   │   ├── mergeable_words.rs
│   │   │   ├── mod.rs
│   │   │   ├── optional.rs
│   │   │   ├── reflexive_pronoun.rs
│   │   │   ├── repeating.rs
│   │   │   ├── sequence_expr.rs
│   │   │   ├── similar_to_phrase.rs
│   │   │   ├── space_or_hyphen.rs
│   │   │   ├── spelled_number_expr.rs
│   │   │   ├── step.rs
│   │   │   ├── time_unit_expr.rs
│   │   │   ├── unless_step.rs
│   │   │   └── word_expr_group.rs
│   │   ├── fat_token.rs
│   │   ├── ignored_lints/
│   │   │   ├── lint_context.rs
│   │   │   └── mod.rs
│   │   ├── indefinite_article.rs
│   │   ├── irregular_nouns.rs
│   │   ├── irregular_verbs.rs
│   │   ├── language_detection.rs
│   │   ├── lexing/
│   │   │   ├── email_address.rs
│   │   │   ├── hostname.rs
│   │   │   ├── mod.rs
│   │   │   └── url.rs
│   │   ├── lib.rs
│   │   ├── linting/
│   │   │   ├── a_part.rs
│   │   │   ├── a_while.rs
│   │   │   ├── addicting.rs
│   │   │   ├── adjective_double_degree.rs
│   │   │   ├── adjective_of_a.rs
│   │   │   ├── after_later.rs
│   │   │   ├── all_hell_break_loose.rs
│   │   │   ├── all_intents_and_purposes.rs
│   │   │   ├── allow_to.rs
│   │   │   ├── am_in_the_morning.rs
│   │   │   ├── amounts_for.rs
│   │   │   ├── an_a.rs
│   │   │   ├── and_in.rs
│   │   │   ├── and_the_like.rs
│   │   │   ├── another_thing_coming.rs
│   │   │   ├── another_think_coming.rs
│   │   │   ├── apart_from.rs
│   │   │   ├── ask_no_preposition.rs
│   │   │   ├── avoid_curses.rs
│   │   │   ├── back_in_the_day.rs
│   │   │   ├── be_allowed.rs
│   │   │   ├── be_worried.rs
│   │   │   ├── behind_the_scenes.rs
│   │   │   ├── best_of_all_time.rs
│   │   │   ├── boring_words.rs
│   │   │   ├── bought.rs
│   │   │   ├── brand_brandish.rs
│   │   │   ├── by_accident.rs
│   │   │   ├── call_them.rs
│   │   │   ├── cant.rs
│   │   │   ├── capitalize_personal_pronouns.rs
│   │   │   ├── cautionary_tale.rs
│   │   │   ├── change_tack.rs
│   │   │   ├── chock_full.rs
│   │   │   ├── closed_compounds.rs
│   │   │   ├── comma_fixes.rs
│   │   │   ├── compound_nouns/
│   │   │   │   ├── compound_noun_after_det_adj.rs
│   │   │   │   ├── compound_noun_after_possessive.rs
│   │   │   │   ├── compound_noun_before_aux_verb.rs
│   │   │   │   └── mod.rs
│   │   │   ├── compound_subject_i.rs
│   │   │   ├── confident.rs
│   │   │   ├── correct_number_suffix.rs
│   │   │   ├── criteria_phenomena.rs
│   │   │   ├── cure_for.rs
│   │   │   ├── currency_placement.rs
│   │   │   ├── damages.rs
│   │   │   ├── dashes.rs
│   │   │   ├── day_and_age.rs
│   │   │   ├── despite_it_is.rs
│   │   │   ├── despite_of.rs
│   │   │   ├── determiner_without_noun.rs
│   │   │   ├── did_past.rs
│   │   │   ├── didnt.rs
│   │   │   ├── discourse_markers.rs
│   │   │   ├── disjoint_prefixes.rs
│   │   │   ├── do_mistake.rs
│   │   │   ├── dot_initialisms.rs
│   │   │   ├── double_click.rs
│   │   │   ├── double_modal.rs
│   │   │   ├── ellipsis_length.rs
│   │   │   ├── else_possessive.rs
│   │   │   ├── ever_every.rs
│   │   │   ├── everyday.rs
│   │   │   ├── expand_memory_shorthands.rs
│   │   │   ├── expand_time_shorthands.rs
│   │   │   ├── expr_linter.rs
│   │   │   ├── far_be_it.rs
│   │   │   ├── fascinated_by.rs
│   │   │   ├── fed_up_with.rs
│   │   │   ├── feel_fell.rs
│   │   │   ├── few_units_of_time_ago.rs
│   │   │   ├── filler_words.rs
│   │   │   ├── find_fine.rs
│   │   │   ├── first_aid_kit.rs
│   │   │   ├── flesh_out_vs_full_fledged.rs
│   │   │   ├── for_noun.rs
│   │   │   ├── free_predicate.rs
│   │   │   ├── friend_of_me.rs
│   │   │   ├── go_so_far_as_to.rs
│   │   │   ├── go_to_war.rs
│   │   │   ├── good_at.rs
│   │   │   ├── handful.rs
│   │   │   ├── have_pronoun.rs
│   │   │   ├── have_take_a_look.rs
│   │   │   ├── hedging.rs
│   │   │   ├── hello_greeting.rs
│   │   │   ├── hereby.rs
│   │   │   ├── hop_hope/
│   │   │   │   ├── mod.rs
│   │   │   │   ├── to_hop.rs
│   │   │   │   └── to_hope.rs
│   │   │   ├── hope_youre.rs
│   │   │   ├── how_to.rs
│   │   │   ├── hyphenate_number_day.rs
│   │   │   ├── i_am_agreement.rs
│   │   │   ├── if_wouldve.rs
│   │   │   ├── in_on_the_cards.rs
│   │   │   ├── inflected_verb_after_to.rs
│   │   │   ├── initialism_linter.rs
│   │   │   ├── initialisms.rs
│   │   │   ├── interested_in.rs
│   │   │   ├── it_is.rs
│   │   │   ├── it_looks_like_that.rs
│   │   │   ├── it_would_be.rs
│   │   │   ├── its_contraction/
│   │   │   │   ├── general.rs
│   │   │   │   ├── mod.rs
│   │   │   │   └── proper_noun.rs
│   │   │   ├── its_possessive.rs
│   │   │   ├── jealous_of.rs
│   │   │   ├── johns_hopkins.rs
│   │   │   ├── lead_rise_to.rs
│   │   │   ├── left_right_hand.rs
│   │   │   ├── less_worse.rs
│   │   │   ├── let_to_do.rs
│   │   │   ├── lets_confusion/
│   │   │   │   ├── let_us_redundancy.rs
│   │   │   │   ├── mod.rs
│   │   │   │   └── no_contraction_with_verb.rs
│   │   │   ├── likewise.rs
│   │   │   ├── lint.rs
│   │   │   ├── lint_group.rs
│   │   │   ├── lint_kind.rs
│   │   │   ├── long_sentences.rs
│   │   │   ├── look_down_ones_nose.rs
│   │   │   ├── looking_forward_to.rs
│   │   │   ├── map_phrase_linter.rs
│   │   │   ├── map_phrase_set_linter.rs
│   │   │   ├── mass_nouns/
│   │   │   │   ├── mass_plurals.rs
│   │   │   │   ├── mod.rs
│   │   │   │   └── noun_countability.rs
│   │   │   ├── means_a_lot_to.rs
│   │   │   ├── merge_linters.rs
│   │   │   ├── merge_words.rs
│   │   │   ├── missing_preposition.rs
│   │   │   ├── missing_space.rs
│   │   │   ├── missing_to.rs
│   │   │   ├── misspell.rs
│   │   │   ├── mixed_bag.rs
│   │   │   ├── mod.rs
│   │   │   ├── modal_be_adjective.rs
│   │   │   ├── modal_of.rs
│   │   │   ├── modal_seem.rs
│   │   │   ├── months.rs
│   │   │   ├── more_adjective.rs
│   │   │   ├── more_better.rs
│   │   │   ├── most_number.rs
│   │   │   ├── most_of_the_times.rs
│   │   │   ├── multiple_frequency_adverbs.rs
│   │   │   ├── multiple_sequential_pronouns.rs
│   │   │   ├── nail_on_the_head.rs
│   │   │   ├── need_to_noun.rs
│   │   │   ├── no_french_spaces.rs
│   │   │   ├── no_longer.rs
│   │   │   ├── no_match_for.rs
│   │   │   ├── no_oxford_comma.rs
│   │   │   ├── nobody.rs
│   │   │   ├── nominal_wants.rs
│   │   │   ├── nor_modal_pronoun.rs
│   │   │   ├── not_only_inversion.rs
│   │   │   ├── noun_verb_confusion/
│   │   │   │   ├── effect_affect/
│   │   │   │   │   ├── affect_to_effect.rs
│   │   │   │   │   ├── effect_to_affect.rs
│   │   │   │   │   └── mod.rs
│   │   │   │   ├── mod.rs
│   │   │   │   ├── noun_instead_of_verb/
│   │   │   │   │   ├── general.rs
│   │   │   │   │   └── mod.rs
│   │   │   │   └── verb_instead_of_noun.rs
│   │   │   ├── number_suffix_capitalization.rs
│   │   │   ├── obsess_preposition.rs
│   │   │   ├── of_course.rs
│   │   │   ├── oldest_in_the_book.rs
│   │   │   ├── on_floor.rs
│   │   │   ├── once_or_twice.rs
│   │   │   ├── one_and_the_same.rs
│   │   │   ├── one_of_the_singular.rs
│   │   │   ├── open_compounds.rs
│   │   │   ├── open_the_light.rs
│   │   │   ├── orthographic_consistency.rs
│   │   │   ├── ought_to_be.rs
│   │   │   ├── out_of_date.rs
│   │   │   ├── oxford_comma.rs
│   │   │   ├── oxymorons.rs
│   │   │   ├── phrasal_verb_as_compound_noun.rs
│   │   │   ├── phrase_set_corrections/
│   │   │   │   ├── mod.rs
│   │   │   │   └── tests.rs
│   │   │   ├── pique_interest.rs
│   │   │   ├── plural_decades/
│   │   │   │   ├── four_digits.rs
│   │   │   │   ├── mod.rs
│   │   │   │   └── two_digits.rs
│   │   │   ├── plural_wrong_word_of_phrase.rs
│   │   │   ├── possessive_noun.rs
│   │   │   ├── possessive_your.rs
│   │   │   ├── progressive_needs_be.rs
│   │   │   ├── pronoun_are.rs
│   │   │   ├── pronoun_contraction/
│   │   │   │   ├── avoid_contraction.rs
│   │   │   │   ├── mod.rs
│   │   │   │   └── should_contract.rs
│   │   │   ├── pronoun_inflection_be.rs
│   │   │   ├── pronoun_knew.rs
│   │   │   ├── pronoun_verb_agreement.rs
│   │   │   ├── proper_noun_capitalization_linters.rs
│   │   │   ├── quantifier_needs_of.rs
│   │   │   ├── quantifier_numeral_conflict.rs
│   │   │   ├── quite_quiet.rs
│   │   │   ├── quote_spacing.rs
│   │   │   ├── reason_for_doing.rs
│   │   │   ├── redundant_acronyms.rs
│   │   │   ├── redundant_additive_adverbs.rs
│   │   │   ├── redundant_progressive_comparative.rs
│   │   │   ├── regionalisms.rs
│   │   │   ├── regular_irregulars.rs
│   │   │   ├── repeated_words.rs
│   │   │   ├── respond.rs
│   │   │   ├── right_click.rs
│   │   │   ├── rise_the_ranks.rs
│   │   │   ├── roller_skated.rs
│   │   │   ├── safe_to_save.rs
│   │   │   ├── save_to_safe.rs
│   │   │   ├── sentence_capitalization.rs
│   │   │   ├── shoot_oneself_in_the_foot.rs
│   │   │   ├── simple_past_to_past_participle.rs
│   │   │   ├── since_duration.rs
│   │   │   ├── single_be.rs
│   │   │   ├── some_without_article.rs
│   │   │   ├── something_is.rs
│   │   │   ├── somewhat_something.rs
│   │   │   ├── soon_to_be.rs
│   │   │   ├── sought_after.rs
│   │   │   ├── spaces.rs
│   │   │   ├── spell_check.rs
│   │   │   ├── spelled_numbers.rs
│   │   │   ├── split_words.rs
│   │   │   ├── subject_pronoun.rs
│   │   │   ├── suggestion.rs
│   │   │   ├── take_a_look_to.rs
│   │   │   ├── take_medicine.rs
│   │   │   ├── take_serious.rs
│   │   │   ├── that_than.rs
│   │   │   ├── that_which.rs
│   │   │   ├── the_how_why.rs
│   │   │   ├── the_my.rs
│   │   │   ├── the_point_for.rs
│   │   │   ├── the_proper_noun_possessive.rs
│   │   │   ├── then_than.rs
│   │   │   ├── theres.rs
│   │   │   ├── theses_these.rs
│   │   │   ├── theyre_confusions/
│   │   │   │   ├── mod.rs
│   │   │   │   ├── over_theyre_to_there.rs
│   │   │   │   └── typographic_theyre_to_their.rs
│   │   │   ├── thing_think.rs
│   │   │   ├── this_type_of_thing.rs
│   │   │   ├── though_thought.rs
│   │   │   ├── throw_away.rs
│   │   │   ├── throw_rubbish.rs
│   │   │   ├── to_adverb.rs
│   │   │   ├── to_two_too/
│   │   │   │   ├── mod.rs
│   │   │   │   ├── to_too_adjective_end.rs
│   │   │   │   ├── to_too_adjective_punct.rs
│   │   │   │   ├── to_too_adjverb_ed_punct.rs
│   │   │   │   ├── to_too_adverb.rs
│   │   │   │   ├── to_too_chunk_start_comma.rs
│   │   │   │   ├── to_too_degree_words.rs
│   │   │   │   ├── to_too_eos.rs
│   │   │   │   ├── to_too_pronoun_end.rs
│   │   │   │   └── too_to.rs
│   │   │   ├── touristic.rs
│   │   │   ├── transposed_space.rs
│   │   │   ├── try_ones_hand_at.rs
│   │   │   ├── unclosed_quotes.rs
│   │   │   ├── update_place_names.rs
│   │   │   ├── use_title_case.rs
│   │   │   ├── verb_to_adjective.rs
│   │   │   ├── very_unique.rs
│   │   │   ├── vice_versa.rs
│   │   │   ├── vicious_loop/
│   │   │   │   └── mod.rs
│   │   │   ├── was_aloud.rs
│   │   │   ├── way_too_adjective.rs
│   │   │   ├── weir_rules/
│   │   │   │   ├── ACoupleMore.weir
│   │   │   │   ├── ALongTime.weir
│   │   │   │   ├── AOkHyphen.weir
│   │   │   │   ├── AdNauseam.weir
│   │   │   │   ├── AfterAWhile.weir
│   │   │   │   ├── AfterAll.weir
│   │   │   │   ├── AheadAnd.weir
│   │   │   │   ├── Albeit.weir
│   │   │   │   ├── AllOfASudden.weir
│   │   │   │   ├── AllReady.weir
│   │   │   │   ├── AllThough.weir
│   │   │   │   ├── Alongside.weir
│   │   │   │   ├── AlzheimersDisease.weir
│   │   │   │   ├── AnAnother.weir
│   │   │   │   ├── AnotherAn.weir
│   │   │   │   ├── AnotherOnes.weir
│   │   │   │   ├── AnotherThings.weir
│   │   │   │   ├── ArriveOnWeekday.weir
│   │   │   │   ├── AsEvidentBy.weir
│   │   │   │   ├── AsFarBackAs.weir
│   │   │   │   ├── AsFollows.weir
│   │   │   │   ├── AsIfThough.weir
│   │   │   │   ├── AsItHappens.weir
│   │   │   │   ├── AsLongAs.weir
│   │   │   │   ├── AsOfCurrently.weir
│   │   │   │   ├── AsOfLately.weir
│   │   │   │   ├── AsOpposedTo.weir
│   │   │   │   ├── AtFaceValue.weir
│   │   │   │   ├── AtTheEndOfTheDay.weir
│   │   │   │   ├── AtTheExpenseOf.weir
│   │   │   │   ├── AvoidAndAlso.weir
│   │   │   │   ├── AwareOf.weir
│   │   │   │   ├── BadRap.weir
│   │   │   │   ├── BanTogether.weir
│   │   │   │   ├── BareInMind.weir
│   │   │   │   ├── BatedBreath.weir
│   │   │   │   ├── BeckAndCall.weir
│   │   │   │   ├── BeenThere.weir
│   │   │   │   ├── Beforehand.weir
│   │   │   │   ├── BesideThePoint.weir
│   │   │   │   ├── BestRegards.weir
│   │   │   │   ├── BetterOffWith.weir
│   │   │   │   ├── BewareOf.weir
│   │   │   │   ├── BlacklistWhitelist.weir
│   │   │   │   ├── BlanketStatement.weir
│   │   │   │   ├── Brutality.weir
│   │   │   │   ├── BuiltIn.weir
│   │   │   │   ├── CanBeSeen.weir
│   │   │   │   ├── CaseInPoint.weir
│   │   │   │   ├── CaseSensitive.weir
│   │   │   │   ├── ClickThroughRate.weir
│   │   │   │   ├── ComprisesOf.weir
│   │   │   │   ├── CondenseAllThe.weir
│   │   │   │   ├── CoursingThroughVeins.weir
│   │   │   │   ├── CuttingAgeEggcorn.weir
│   │   │   │   ├── Cybersec.weir
│   │   │   │   ├── DampSquib.weir
│   │   │   │   ├── DegreesKelvin.weir
│   │   │   │   ├── DegreesKelvinSymbol.weir
│   │   │   │   ├── DoIAdjective.weir
│   │   │   │   ├── DoNotWant.weir
│   │   │   │   ├── DoToDueTo.weir
│   │   │   │   ├── DontCan.weir
│   │   │   │   ├── DoubleNegative.weir
│   │   │   │   ├── DueDiligence.weir
│   │   │   │   ├── DuringAges.weir
│   │   │   │   ├── EachAndEveryOne.weir
│   │   │   │   ├── EagleEyed.weir
│   │   │   │   ├── EggYolk.weir
│   │   │   │   ├── EludedTo.weir
│   │   │   │   ├── EnMasse.weir
│   │   │   │   ├── EnRoute.weir
│   │   │   │   ├── EverPresent.weir
│   │   │   │   ├── EverSince.weir
│   │   │   │   ├── EveryOnceAndAgain.weir
│   │   │   │   ├── EveryTime.weir
│   │   │   │   ├── Excellent.weir
│   │   │   │   ├── ExpandBecause.weir
│   │   │   │   ├── ExpandControl.weir
│   │   │   │   ├── ExpandForward.weir
│   │   │   │   ├── ExpandMinimum.weir
│   │   │   │   ├── ExpandPrevious.weir
│   │   │   │   ├── ExpandThrough.weir
│   │   │   │   ├── ExpandWith.weir
│   │   │   │   ├── ExpandWithout.weir
│   │   │   │   ├── FaceFirst.weir
│   │   │   │   ├── FairBit.weir
│   │   │   │   ├── FarAndFewBetween.weir
│   │   │   │   ├── FastPaste.weir
│   │   │   │   ├── FatalOutcome.weir
│   │   │   │   ├── FetalPosition.weir
│   │   │   │   ├── ForALongTime.weir
│   │   │   │   ├── ForAWhile.weir
│   │   │   │   ├── ForArgumentsSake.weir
│   │   │   │   ├── ForTheMostPart.weir
│   │   │   │   ├── FreeRein.weir
│   │   │   │   ├── Freezing.weir
│   │   │   │   ├── FromTheGetGo.weir
│   │   │   │   ├── GildedAge.weir
│   │   │   │   ├── GoggleBrand.weir
│   │   │   │   ├── GoingTo.weir
│   │   │   │   ├── GuineaBissau.weir
│   │   │   │   ├── HadOf.weir
│   │   │   │   ├── HalfAnHour.weir
│   │   │   │   ├── Haphazard.weir
│   │   │   │   ├── HeDos.weir
│   │   │   │   ├── HeartToHeard.weir
│   │   │   │   ├── HiddenIn.weir
│   │   │   │   ├── HowMach.weir
│   │   │   │   ├── HumanBeings.weir
│   │   │   │   ├── HumanLife.weir
│   │   │   │   ├── HungerPang.weir
│   │   │   │   ├── IAm.weir
│   │   │   │   ├── IDo.weir
│   │   │   │   ├── ImitateFrom.weir
│   │   │   │   ├── InAHurry.weir
│   │   │   │   ├── InAWhile.weir
│   │   │   │   ├── InAnyWay.weir
│   │   │   │   ├── InLieuOf.weir
│   │   │   │   ├── InNeedOf.weir
│   │   │   │   ├── InOfItself.weir
│   │   │   │   ├── InThe.weir
│   │   │   │   ├── Initiatively.weir
│   │   │   │   ├── Insensitive.weir
│   │   │   │   ├── InsteadOf.weir
│   │   │   │   ├── Insurmountable.weir
│   │   │   │   ├── IsKnownFor.weir
│   │   │   │   ├── ItCan.weir
│   │   │   │   ├── IveGotTo.weir
│   │   │   │   ├── JawDropping.weir
│   │   │   │   ├── JustDeserts.weir
│   │   │   │   ├── KindOf.weir
│   │   │   │   ├── KindRegards.weir
│   │   │   │   ├── KindSortOf.weir
│   │   │   │   ├── LastButNotLeast.weir
│   │   │   │   ├── LastDitch.weir
│   │   │   │   ├── LastNight.weir
│   │   │   │   ├── LaughOfAt.weir
│   │   │   │   ├── LeaveToFor.weir
│   │   │   │   ├── LetAlone.weir
│   │   │   │   ├── LikeAsIf.weir
│   │   │   │   ├── LikeThePlague.weir
│   │   │   │   ├── LikeTheresNoTomorrow.weir
│   │   │   │   ├── LikelyHood.weir
│   │   │   │   ├── LinesOfCode.weir
│   │   │   │   ├── LooksLikes.weir
│   │   │   │   ├── LowHangingFruit.weir
│   │   │   │   ├── ManagerialReins.weir
│   │   │   │   ├── MercedesBenzHyphen.weir
│   │   │   │   ├── MissingDeterminer.weir
│   │   │   │   ├── Monumentous.weir
│   │   │   │   ├── MoreThatLikely.weir
│   │   │   │   ├── MyHouse.weir
│   │   │   │   ├── NeedHelp.weir
│   │   │   │   ├── NerveRacking.weir
│   │   │   │   ├── NobelPeacePrize.weir
│   │   │   │   ├── NotBeAfterNot.weir
│   │   │   │   ├── NotIn.weir
│   │   │   │   ├── NotTo.weir
│   │   │   │   ├── NowWay.weir
│   │   │   │   ├── OffTheCuff.weir
│   │   │   │   ├── OldWivesTale.weir
│   │   │   │   ├── OnFirstGlance.weir
│   │   │   │   ├── OnSecondThought.weir
│   │   │   │   ├── OnTheSpurOfTheMoment.weir
│   │   │   │   ├── OnTopOf.weir
│   │   │   │   ├── OnceInAWhile.weir
│   │   │   │   ├── OneFellSwoop.weir
│   │   │   │   ├── OneHanded.weir
│   │   │   │   ├── OutOfSync.weir
│   │   │   │   ├── PartsOfSpeech.weir
│   │   │   │   ├── PasswordProtectedHyphen.weir
│   │   │   │   ├── PeaceOfMind.weir
│   │   │   │   ├── PedalToTheMetal.weir
│   │   │   │   ├── PerSe.weir
│   │   │   │   ├── PointsOfView.weir
│   │   │   │   ├── PortAuPrince.weir
│   │   │   │   ├── PortoNovo.weir
│   │   │   │   ├── PrayingMantis.weir
│   │   │   │   ├── QuiteMany.weir
│   │   │   │   ├── RainbowColoredHyphen.weir
│   │   │   │   ├── RallyToReally.weir
│   │   │   │   ├── RapidFire.weir
│   │   │   │   ├── RealTrouper.weir
│   │   │   │   ├── RedundantIIRC.weir
│   │   │   │   ├── RedundantPretty.weir
│   │   │   │   ├── RedundantThat.weir
│   │   │   │   ├── RifeWith.weir
│   │   │   │   ├── RoadMap.weir
│   │   │   │   ├── RulesOfThumb.weir
│   │   │   │   ├── SameAs.weir
│   │   │   │   ├── ScantilyClad.weir
│   │   │   │   ├── SendAnEmailTo.weir
│   │   │   │   ├── ShutdownVerb.weir
│   │   │   │   ├── SimilarLike.weir
│   │   │   │   ├── SimpleGrammatical.weir
│   │   │   │   ├── SneakingSuspicion.weir
│   │   │   │   ├── SomeOfThe.weir
│   │   │   │   ├── SomebodyElses.weir
│   │   │   │   ├── SoonerOrLater.weir
│   │   │   │   ├── SpecialAttention.weir
│   │   │   │   ├── SpinalChord.weir
│   │   │   │   ├── Starving.weir
│   │   │   │   ├── StateOfTheArt.weir
│   │   │   │   ├── StatuteOfLimitations.weir
│   │   │   │   ├── StrikeChord.weir
│   │   │   │   ├── SufficeItToSay.weir
│   │   │   │   ├── SupposedTo.weir
│   │   │   │   ├── TakeItPersonally.weir
│   │   │   │   ├── ThanksALot.weir
│   │   │   │   ├── ThatChallenged.weir
│   │   │   │   ├── ThatThis.weir
│   │   │   │   ├── The.weir
│   │   │   │   ├── TheAnother.weir
│   │   │   │   ├── TheDifferenceBetween.weir
│   │   │   │   ├── TheirToThere.weir
│   │   │   │   ├── TheirToTheyre.weir
│   │   │   │   ├── ThereToTheir.weir
│   │   │   │   ├── TheyToThem.weir
│   │   │   │   ├── TheyreToTheir.weir
│   │   │   │   ├── ThoughtProcess.weir
│   │   │   │   ├── ThreatenVerb.weir
│   │   │   │   ├── TickingTimeClock.weir
│   │   │   │   ├── ToBackOut.weir
│   │   │   │   ├── ToDoHyphen.weir
│   │   │   │   ├── ToGreatLengths.weir
│   │   │   │   ├── ToLoseTooLoose.weir
│   │   │   │   ├── ToSomeDegree.weir
│   │   │   │   ├── ToTheMannerBorn.weir
│   │   │   │   ├── ToWorryAbout.weir
│   │   │   │   ├── TongueInCheek.weir
│   │   │   │   ├── Towards.weir
│   │   │   │   ├── TrialAndError.weir
│   │   │   │   ├── TrueToWord.weir
│   │   │   │   ├── TuffEnough.weir
│   │   │   │   ├── TurnItOff.weir
│   │   │   │   ├── Unless.weir
│   │   │   │   ├── VeryKnown.weir
│   │   │   │   ├── VeryLess.weir
│   │   │   │   ├── WantBe.weir
│   │   │   │   ├── WaveFunction.weir
│   │   │   │   ├── WellBeing.weir
│   │   │   │   ├── WellKept.weir
│   │   │   │   ├── WhetYourAppetite.weir
│   │   │   │   ├── WillContain.weir
│   │   │   │   ├── WithoutOut.weir
│   │   │   │   ├── WorstCaseScenario.weir
│   │   │   │   ├── WroughtIron.weir
│   │   │   │   ├── YeaToYeah.weir
│   │   │   │   ├── YehToYeah.weir
│   │   │   │   ├── YourPredicateAdjective.weir
│   │   │   │   └── mod.rs
│   │   │   ├── well_educated.rs
│   │   │   ├── were_where.rs
│   │   │   ├── whereas.rs
│   │   │   ├── whom_subject_of_verb.rs
│   │   │   ├── widely_accepted.rs
│   │   │   ├── win_prize.rs
│   │   │   ├── wish_could.rs
│   │   │   ├── wordpress_dotcom.rs
│   │   │   ├── worth_to_do.rs
│   │   │   ├── would_never_have.rs
│   │   │   └── wrong_apostrophe.rs
│   │   ├── mask/
│   │   │   ├── mod.rs
│   │   │   └── regex_masker.rs
│   │   ├── number.rs
│   │   ├── offsets.rs
│   │   ├── parsers/
│   │   │   ├── collapse_identifiers.rs
│   │   │   ├── isolate_english.rs
│   │   │   ├── markdown.rs
│   │   │   ├── mask.rs
│   │   │   ├── mod.rs
│   │   │   ├── oops_all_headings.rs
│   │   │   ├── org_mode.rs
│   │   │   └── plain_english.rs
│   │   ├── patterns/
│   │   │   ├── any_pattern.rs
│   │   │   ├── derived_from.rs
│   │   │   ├── implies_quantity.rs
│   │   │   ├── indefinite_article.rs
│   │   │   ├── inflection_of_be.rs
│   │   │   ├── invert.rs
│   │   │   ├── mod.rs
│   │   │   ├── modal_verb.rs
│   │   │   ├── nominal_phrase.rs
│   │   │   ├── prepositional_preceder.rs
│   │   │   ├── upos_set.rs
│   │   │   ├── whitespace_pattern.rs
│   │   │   ├── within_edit_distance.rs
│   │   │   ├── word.rs
│   │   │   └── word_set.rs
│   │   ├── punctuation.rs
│   │   ├── render_markdown.rs
│   │   ├── span.rs
│   │   ├── spell/
│   │   │   ├── dictionary.rs
│   │   │   ├── fst_dictionary.rs
│   │   │   ├── merged_dictionary.rs
│   │   │   ├── mod.rs
│   │   │   ├── mutable_dictionary.rs
│   │   │   ├── rune/
│   │   │   │   ├── affix_replacement.rs
│   │   │   │   ├── attribute_list.rs
│   │   │   │   ├── error.rs
│   │   │   │   ├── expansion.rs
│   │   │   │   ├── matcher.rs
│   │   │   │   ├── mod.rs
│   │   │   │   └── word_list.rs
│   │   │   ├── trie_dictionary.rs
│   │   │   ├── word_id.rs
│   │   │   └── word_map.rs
│   │   ├── sync.rs
│   │   ├── thesaurus_helper.rs
│   │   ├── title_case.rs
│   │   ├── token.rs
│   │   ├── token_kind.rs
│   │   ├── token_string_ext.rs
│   │   ├── vec_ext.rs
│   │   ├── weir/
│   │   │   ├── ast.rs
│   │   │   ├── error.rs
│   │   │   ├── mod.rs
│   │   │   ├── optimize.rs
│   │   │   └── parsing/
│   │   │       ├── expr.rs
│   │   │       ├── mod.rs
│   │   │       └── stmt.rs
│   │   └── weirpack/
│   │       ├── error.rs
│   │       ├── manifest.rs
│   │       └── mod.rs
│   └── tests/
│       ├── linters.rs
│       ├── pos_tags.rs
│       ├── run_tests.rs
│       ├── snapshot.rs
│       ├── test_sources/
│       │   ├── allows_domain_extensions.md
│       │   ├── amazon_hostname.md
│       │   ├── chinese_lorem_ipsum.md
│       │   ├── hex_basic_clean.md
│       │   ├── hex_basic_dirty.md
│       │   ├── index.org
│       │   ├── issue_109.md
│       │   ├── issue_109_ext.md
│       │   ├── issue_118.md
│       │   ├── issue_1581.md
│       │   ├── issue_159.md
│       │   ├── issue_1873.md
│       │   ├── issue_195.md
│       │   ├── issue_1988.md
│       │   ├── issue_2054.md
│       │   ├── issue_2054_clean.md
│       │   ├── issue_2151.md
│       │   ├── issue_2233.md
│       │   ├── issue_2240.md
│       │   ├── issue_2246.md
│       │   ├── issue_267.md
│       │   ├── issue_358.md
│       │   ├── lots_of_latin.md
│       │   ├── lukas_homework.md
│       │   ├── misc_closed_compound_clean.md
│       │   ├── obsidian_links.md
│       │   ├── pr_452.md
│       │   ├── pr_504.md
│       │   ├── proper_noun_capitalization.md
│       │   ├── statist_localist.md
│       │   ├── title_case_clean.md
│       │   ├── title_case_errors.md
│       │   ├── whack_bullets.md
│       │   └── yogurt_british_clean.md
│       └── text/
│           ├── Alice's Adventures in Wonderland.md
│           ├── Computer science.md
│           ├── Difficult sentences.md
│           ├── Part-of-speech tagging.md
│           ├── Spell.US.md
│           ├── Spell.md
│           ├── Swear.md
│           ├── The Constitution of the United States.md
│           ├── The Great Gatsby.md
│           ├── linters/
│           │   ├── Alice's Adventures in Wonderland.snap.yml
│           │   ├── Computer science.snap.yml
│           │   ├── Difficult sentences.snap.yml
│           │   ├── Part-of-speech tagging.snap.yml
│           │   ├── Spell.US.snap.yml
│           │   ├── Spell.snap.yml
│           │   ├── Swear.snap.yml
│           │   ├── The Constitution of the United States.snap.yml
│           │   ├── The Great Gatsby.snap.yml
│           │   └── this and that.snap.yml
│           ├── tagged/
│           │   ├── Alice's Adventures in Wonderland.md
│           │   ├── Computer science.md
│           │   ├── Difficult sentences.md
│           │   ├── Part-of-speech tagging.md
│           │   ├── Spell.US.md
│           │   ├── Spell.md
│           │   ├── Swear.md
│           │   ├── The Constitution of the United States.md
│           │   ├── The Great Gatsby.md
│           │   └── this and that.md
│           └── this and that.md
├── harper-html/
│   ├── Cargo.toml
│   ├── src/
│   │   └── lib.rs
│   └── tests/
│       ├── run_tests.rs
│       └── test_sources/
│           ├── issue_156.html
│           ├── issue_541.html
│           └── run_on.html
├── harper-ink/
│   ├── Cargo.toml
│   ├── src/
│   │   └── lib.rs
│   └── tests/
│       ├── run_tests.rs
│       └── test_sources/
│           ├── bad.ink
│           └── good.ink
├── harper-jjdescription/
│   ├── Cargo.toml
│   ├── src/
│   │   └── lib.rs
│   └── tests/
│       ├── run_tests.rs
│       └── test_sources/
│           ├── complex_verbose_description.txt
│           ├── conventional_description.txt
│           └── simple_description.txt
├── harper-literate-haskell/
│   ├── Cargo.toml
│   ├── src/
│   │   ├── lib.rs
│   │   └── masker.rs
│   └── tests/
│       ├── run_tests.rs
│       └── test_sources/
│           ├── bird_format.lhs
│           ├── latex_format.lhs
│           └── mixed_format.lhs
├── harper-ls/
│   ├── Cargo.toml
│   ├── README.md
│   └── src/
│       ├── backend.rs
│       ├── config.rs
│       ├── diagnostics.rs
│       ├── dictionary_io.rs
│       ├── document_state.rs
│       ├── git_commit_parser.rs
│       ├── ignored_lints_io.rs
│       ├── io_utils.rs
│       ├── main.rs
│       └── pos_conv.rs
├── harper-pos-utils/
│   ├── Cargo.toml
│   └── src/
│       ├── chunker/
│       │   ├── brill_chunker/
│       │   │   ├── mod.rs
│       │   │   └── patch.rs
│       │   ├── burn_chunker.rs
│       │   ├── cached_chunker.rs
│       │   ├── mod.rs
│       │   ├── np_extraction.rs
│       │   └── upos_freq_dict.rs
│       ├── conllu_utils.rs
│       ├── lib.rs
│       ├── patch_criteria.rs
│       ├── tagger/
│       │   ├── brill_tagger/
│       │   │   ├── mod.rs
│       │   │   └── patch.rs
│       │   ├── error_counter.rs
│       │   ├── freq_dict.rs
│       │   ├── freq_dict_builder.rs
│       │   └── mod.rs
│       ├── upos.rs
│       └── word_counter.rs
├── harper-python/
│   ├── Cargo.toml
│   ├── src/
│   │   └── lib.rs
│   └── tests/
│       ├── run_tests.rs
│       └── test_sources/
│           ├── comments.py
│           ├── docstrings.py
│           └── field_docstrings.py
├── harper-stats/
│   ├── Cargo.toml
│   ├── README.md
│   └── src/
│       ├── lib.rs
│       ├── record.rs
│       └── summary.rs
├── harper-tex/
│   ├── Cargo.toml
│   ├── src/
│   │   ├── lib.rs
│   │   └── masker.rs
│   └── tests/
│       ├── run_tests.rs
│       └── test_sources/
│           ├── city.tex
│           ├── clean.tex
│           ├── em_dash.tex
│           ├── heading.tex
│           ├── issue_2835.tex
│           ├── many_more_tags.tex
│           ├── many_tags.tex
│           ├── simple.tex
│           └── title.tex
├── harper-thesaurus/
│   ├── Cargo.toml
│   ├── build.rs
│   ├── clippy.toml
│   ├── src/
│   │   ├── lib.rs
│   │   └── thesaurus.rs
│   ├── thesaurus.txt
│   └── word-freq.txt
├── harper-tree-sitter/
│   ├── Cargo.toml
│   └── src/
│       └── lib.rs
├── harper-typst/
│   ├── Cargo.toml
│   ├── src/
│   │   ├── lib.rs
│   │   ├── offset_cursor.rs
│   │   └── typst_translator.rs
│   └── tests/
│       ├── run_tests.rs
│       ├── test_sources/
│       │   ├── complex_document.typ
│       │   ├── complex_document_with_spelling_mistakes.typ
│       │   ├── contractions.typ
│       │   ├── function_with_ignorable_args.typ
│       │   ├── issue_1926.typ
│       │   ├── issue_399.typ
│       │   └── simplified_document.typ
│       └── tests.rs
├── harper-wasm/
│   ├── Cargo.toml
│   ├── README.md
│   └── src/
│       └── lib.rs
├── justfile
├── package.json
├── packages/
│   ├── chrome-plugin/
│   │   ├── .editorconfig
│   │   ├── .gitignore
│   │   ├── .npmignore
│   │   ├── CHANGELOG.md
│   │   ├── LICENSE
│   │   ├── app.css
│   │   ├── options.html
│   │   ├── package.json
│   │   ├── playwright.config.ts
│   │   ├── popup.html
│   │   ├── public/
│   │   │   ├── google-docs-bridge-request-handler.js
│   │   │   ├── google-docs-bridge.js
│   │   │   └── google-docs-protocol.js
│   │   ├── sidepanel.html
│   │   ├── src/
│   │   │   ├── PopupState.ts
│   │   │   ├── ProtocolClient.ts
│   │   │   ├── background/
│   │   │   │   ├── detectDialect.ts
│   │   │   │   └── index.ts
│   │   │   ├── contentScript/
│   │   │   │   ├── GoogleDocsBridgeClient.ts
│   │   │   │   ├── googleDocs.ts
│   │   │   │   ├── googleDocsBootstrap.js
│   │   │   │   ├── googleDocsLayout.ts
│   │   │   │   └── index.ts
│   │   │   ├── detectBrowserEngine.ts
│   │   │   ├── generateGreeting.ts
│   │   │   ├── global.d.ts
│   │   │   ├── isSubstack.ts
│   │   │   ├── isWordPress.ts
│   │   │   ├── manifest.ts
│   │   │   ├── options/
│   │   │   │   ├── Options.svelte
│   │   │   │   └── index.ts
│   │   │   ├── popup/
│   │   │   │   ├── Main.svelte
│   │   │   │   ├── Onboarding.svelte
│   │   │   │   ├── Popup.svelte
│   │   │   │   ├── ReportProblematicLint.svelte
│   │   │   │   └── index.ts
│   │   │   ├── protocol.ts
│   │   │   ├── theme.ts
│   │   │   └── zip.js
│   │   ├── tests/
│   │   │   ├── draft.spec.ts
│   │   │   ├── fixtures.ts
│   │   │   ├── github.spec.ts
│   │   │   ├── google_docs.spec.ts
│   │   │   ├── hn.spec.ts
│   │   │   ├── lexical.spec.ts
│   │   │   ├── lexical_webcomponent.spec.ts
│   │   │   ├── lint-kinds.spec.ts
│   │   │   ├── nested_elements.spec.ts
│   │   │   ├── pages/
│   │   │   │   ├── github_textarea.html
│   │   │   │   ├── lexical_webcomponent.html
│   │   │   │   ├── nested_elements.html
│   │   │   │   ├── quill_simple.html
│   │   │   │   ├── simple_inputs_disabled.html
│   │   │   │   └── simple_textarea.html
│   │   │   ├── prosemirror.spec.ts
│   │   │   ├── quill.spec.ts
│   │   │   ├── review_banner.spec.ts
│   │   │   ├── simple_inputs_disabled.spec.ts
│   │   │   ├── simple_textarea.spec.ts
│   │   │   ├── slate.spec.ts
│   │   │   ├── testUtils.ts
│   │   │   └── typst.spec.ts
│   │   ├── tsconfig.json
│   │   ├── tsconfig.node.json
│   │   └── vite.config.ts
│   ├── components/
│   │   ├── .gitignore
│   │   ├── .npmrc
│   │   ├── package.json
│   │   ├── src/
│   │   │   ├── app.d.ts
│   │   │   ├── app.html
│   │   │   ├── lib/
│   │   │   │   ├── Button.svelte
│   │   │   │   ├── Card.svelte
│   │   │   │   ├── Collapsible.svelte
│   │   │   │   ├── Input.svelte
│   │   │   │   ├── Link.svelte
│   │   │   │   ├── Select.svelte
│   │   │   │   ├── Textarea.svelte
│   │   │   │   ├── index.ts
│   │   │   │   └── styles.css
│   │   │   └── routes/
│   │   │       ├── +layout.svelte
│   │   │       ├── +page.svelte
│   │   │       └── layout.css
│   │   ├── svelte.config.js
│   │   ├── tsconfig.json
│   │   └── vite.config.ts
│   ├── harper.js/
│   │   ├── .gitignore
│   │   ├── README.md
│   │   ├── api-extractor.json
│   │   ├── docs.sh
│   │   ├── examples/
│   │   │   ├── commonjs-simple/
│   │   │   │   ├── README.md
│   │   │   │   ├── index.js
│   │   │   │   └── package.json
│   │   │   └── raw-web/
│   │   │       ├── README.md
│   │   │       └── index.html
│   │   ├── package.json
│   │   ├── renderPage.js
│   │   ├── src/
│   │   │   ├── Linter.bench.ts
│   │   │   ├── Linter.test.ts
│   │   │   ├── Linter.ts
│   │   │   ├── LocalLinter.ts
│   │   │   ├── Serializer.test.ts
│   │   │   ├── Serializer.ts
│   │   │   ├── Summary.ts
│   │   │   ├── WorkerLinter/
│   │   │   │   ├── index.ts
│   │   │   │   ├── shims.ts
│   │   │   │   └── worker.ts
│   │   │   ├── binary.ts
│   │   │   ├── main.ts
│   │   │   ├── utils.ts
│   │   │   ├── weirpack.test.ts
│   │   │   └── weirpack.ts
│   │   ├── tsconfig.json
│   │   └── vite.config.ts
│   ├── lint-framework/
│   │   ├── .gitignore
│   │   ├── README.md
│   │   ├── package.json
│   │   ├── src/
│   │   │   ├── assets/
│   │   │   │   ├── bookDownSvg.ts
│   │   │   │   └── hints.json
│   │   │   ├── index.ts
│   │   │   └── lint/
│   │   │       ├── Box.ts
│   │   │       ├── Highlights.ts
│   │   │       ├── LintFramework.ts
│   │   │       ├── PopupHandler.ts
│   │   │       ├── RenderBox.ts
│   │   │       ├── SourceElement.ts
│   │   │       ├── SuggestionBox.ts
│   │   │       ├── TextFieldRange.ts
│   │   │       ├── computeLintBoxes.ts
│   │   │       ├── domUtils.ts
│   │   │       ├── editorUtils.ts
│   │   │       ├── lintKindColor.ts
│   │   │       ├── unpackLint.ts
│   │   │       └── utils.ts
│   │   ├── tsconfig.json
│   │   └── vite.config.ts
│   ├── obsidian-plugin/
│   │   ├── .gitignore
│   │   ├── README.md
│   │   ├── package.json
│   │   ├── src/
│   │   │   ├── HarperSettingTab.ts
│   │   │   ├── State.test.ts
│   │   │   ├── State.ts
│   │   │   ├── index.ts
│   │   │   ├── lint.test.ts
│   │   │   ├── lint.ts
│   │   │   ├── lintKindColor.test.ts
│   │   │   ├── lintKindColor.ts
│   │   │   ├── textUtils.test.ts
│   │   │   └── textUtils.ts
│   │   └── vite.config.ts
│   ├── vscode-plugin/
│   │   ├── .gitignore
│   │   ├── .vscodeignore
│   │   ├── README.md
│   │   ├── development-guide.md
│   │   ├── esbuild.cjs
│   │   ├── package.json
│   │   ├── src/
│   │   │   ├── extension.ts
│   │   │   └── tests/
│   │   │       ├── fixtures/
│   │   │       │   ├── integration.md
│   │   │       │   └── languages/
│   │   │       │       ├── CMakeLists.txt
│   │   │       │       ├── c.c
│   │   │       │       ├── cpp.cpp
│   │   │       │       ├── cpp.h
│   │   │       │       ├── csharp.cs
│   │   │       │       ├── dart.dart
│   │   │       │       ├── git-commit
│   │   │       │       ├── go.go
│   │   │       │       ├── groovy.groovy
│   │   │       │       ├── haskell.hs
│   │   │       │       ├── html.html
│   │   │       │       ├── java.java
│   │   │       │       ├── javascript.js
│   │   │       │       ├── javascriptreact.jsx
│   │   │       │       ├── latex.tex
│   │   │       │       ├── literate-haskell.lhs
│   │   │       │       ├── lua.lua
│   │   │       │       ├── nix.nix
│   │   │       │       ├── php.php
│   │   │       │       ├── plaintext
│   │   │       │       ├── plaintext.txt
│   │   │       │       ├── powershell.ps1
│   │   │       │       ├── python.py
│   │   │       │       ├── ruby.rb
│   │   │       │       ├── rust.rs
│   │   │       │       ├── shellscript
│   │   │       │       ├── shellscript.bash
│   │   │       │       ├── shellscript.sh
│   │   │       │       ├── solidity.sol
│   │   │       │       ├── swift.swift
│   │   │       │       ├── toml.toml
│   │   │       │       ├── typescript.ts
│   │   │       │       ├── typescriptreact.tsx
│   │   │       │       ├── typst.typ
│   │   │       │       └── zig.zig
│   │   │       ├── runTests.ts
│   │   │       └── suite/
│   │   │           ├── helper.ts
│   │   │           ├── index.ts
│   │   │           ├── integration.test.ts
│   │   │           └── languages.test.ts
│   │   └── tsconfig.json
│   ├── web/
│   │   ├── .dockerignore
│   │   ├── .gitignore
│   │   ├── README.md
│   │   ├── demo_wp_blueprint.json
│   │   ├── drizzle/
│   │   │   ├── 0000_cute_zuras.sql
│   │   │   ├── 0001_blushing_corsair.sql
│   │   │   ├── 0002_blushing_chameleon.sql
│   │   │   └── meta/
│   │   │       ├── 0000_snapshot.json
│   │   │       ├── 0001_snapshot.json
│   │   │       ├── 0002_snapshot.json
│   │   │       └── _journal.json
│   │   ├── drizzle.config.ts
│   │   ├── package.json
│   │   ├── src/
│   │   │   ├── app.css
│   │   │   ├── app.d.ts
│   │   │   ├── app.html
│   │   │   ├── brace.d.ts
│   │   │   ├── hooks.server.ts
│   │   │   ├── lib/
│   │   │   │   ├── GitHubClient.ts
│   │   │   │   ├── components/
│   │   │   │   │   ├── AutomatticLogo.svelte
│   │   │   │   │   ├── ChromeLogo.svelte
│   │   │   │   │   ├── CodeLogo.svelte
│   │   │   │   │   ├── DefaultNeovimConfig.svelte
│   │   │   │   │   ├── EdgeLogo.svelte
│   │   │   │   │   ├── Editor.svelte
│   │   │   │   │   ├── EmacsLogo.svelte
│   │   │   │   │   ├── FirefoxLogo.svelte
│   │   │   │   │   ├── GitHubLogo.svelte
│   │   │   │   │   ├── Graph.svelte
│   │   │   │   │   ├── GutterCenter.svelte
│   │   │   │   │   ├── HelixLogo.svelte
│   │   │   │   │   ├── Isolate.svelte
│   │   │   │   │   ├── LazyEditor.svelte
│   │   │   │   │   ├── LintCard.svelte
│   │   │   │   │   ├── LintKindChart.svelte
│   │   │   │   │   ├── LintSidebar.svelte
│   │   │   │   │   ├── Logo.svelte
│   │   │   │   │   ├── NeovimLogo.svelte
│   │   │   │   │   ├── ObsidianLogo.svelte
│   │   │   │   │   ├── Section.svelte
│   │   │   │   │   ├── SublimeLogo.svelte
│   │   │   │   │   ├── Testimonial.svelte
│   │   │   │   │   ├── TestimonialCollection.svelte
│   │   │   │   │   ├── Toasts.svelte
│   │   │   │   │   ├── WeirStudioFileExplorer.svelte
│   │   │   │   │   ├── WeirStudioStart.svelte
│   │   │   │   │   ├── WeirStudioWorkspace.svelte
│   │   │   │   │   ├── WordPressLogo.svelte
│   │   │   │   │   ├── ZedLogo.svelte
│   │   │   │   │   └── icons/
│   │   │   │   │       ├── CheckIcon.svelte
│   │   │   │   │       ├── ChevronLeftIcon.svelte
│   │   │   │   │       ├── ChevronRightIcon.svelte
│   │   │   │   │       ├── CloseIcon.svelte
│   │   │   │   │       ├── DownloadIcon.svelte
│   │   │   │   │       ├── EditIcon.svelte
│   │   │   │   │       ├── PlayIcon.svelte
│   │   │   │   │       ├── PlusIcon.svelte
│   │   │   │   │       └── TrashIcon.svelte
│   │   │   │   └── db/
│   │   │   │       ├── index.ts
│   │   │   │       ├── models/
│   │   │   │       │   ├── ProblematicLints.ts
│   │   │   │       │   └── UninstallFeedback.ts
│   │   │   │       └── schema.ts
│   │   │   └── routes/
│   │   │       ├── +layout.svelte
│   │   │       ├── +page.svelte
│   │   │       ├── api/
│   │   │       │   ├── problematic-lints/
│   │   │       │   │   └── +server.ts
│   │   │       │   └── uninstall-feedback/
│   │   │       │       └── +server.ts
│   │   │       ├── cache-healthcheck/
│   │   │       │   └── +server.ts
│   │   │       ├── docs/
│   │   │       │   ├── about/
│   │   │       │   │   ├── +page.md
│   │   │       │   │   └── +page.ts
│   │   │       │   ├── contributors/
│   │   │       │   │   ├── architecture/
│   │   │       │   │   │   └── +page.md
│   │   │       │   │   ├── author-a-rule/
│   │   │       │   │   │   └── +page.md
│   │   │       │   │   ├── brill/
│   │   │       │   │   │   └── +page.md
│   │   │       │   │   ├── chrome-extension/
│   │   │       │   │   │   └── +page.md
│   │   │       │   │   ├── committing/
│   │   │       │   │   │   └── +page.md
│   │   │       │   │   ├── dictionary/
│   │   │       │   │   │   └── +page.md
│   │   │       │   │   ├── environment/
│   │   │       │   │   │   └── +page.md
│   │   │       │   │   ├── faq/
│   │   │       │   │   │   └── +page.md
│   │   │       │   │   ├── introduction/
│   │   │       │   │   │   └── +page.md
│   │   │       │   │   ├── local-stats/
│   │   │       │   │   │   └── +page.md
│   │   │       │   │   ├── obsidian/
│   │   │       │   │   │   └── +page.md
│   │   │       │   │   ├── review/
│   │   │       │   │   │   └── +page.md
│   │   │       │   │   ├── tests/
│   │   │       │   │   │   └── +page.md
│   │   │       │   │   ├── visual-studio-code/
│   │   │       │   │   │   └── +page.md
│   │   │       │   │   └── wordpress/
│   │   │       │   │       └── +page.md
│   │   │       │   ├── harperjs/
│   │   │       │   │   ├── CDN/
│   │   │       │   │   │   ├── +page.md
│   │   │       │   │   │   └── example/
│   │   │       │   │   │       └── +server.ts
│   │   │       │   │   ├── configurerules/
│   │   │       │   │   │   └── +page.md
│   │   │       │   │   ├── introduction/
│   │   │       │   │   │   └── +page.md
│   │   │       │   │   ├── linting/
│   │   │       │   │   │   └── +page.md
│   │   │       │   │   ├── node/
│   │   │       │   │   │   └── +page.md
│   │   │       │   │   └── spans/
│   │   │       │   │       └── +page.md
│   │   │       │   ├── integrations/
│   │   │       │   │   ├── chrome-extension/
│   │   │       │   │   │   └── +page.md
│   │   │       │   │   ├── emacs/
│   │   │       │   │   │   └── +page.md
│   │   │       │   │   ├── firefox-extension/
│   │   │       │   │   │   └── +page.md
│   │   │       │   │   ├── helix/
│   │   │       │   │   │   └── +page.md
│   │   │       │   │   ├── language-server/
│   │   │       │   │   │   └── +page.md
│   │   │       │   │   ├── neovim/
│   │   │       │   │   │   └── +page.md
│   │   │       │   │   ├── obsidian/
│   │   │       │   │   │   └── +page.md
│   │   │       │   │   ├── sublime-text/
│   │   │       │   │   │   └── +page.md
│   │   │       │   │   ├── visual-studio-code/
│   │   │       │   │   │   └── +page.md
│   │   │       │   │   ├── wordpress/
│   │   │       │   │   │   └── +page.md
│   │   │       │   │   └── zed/
│   │   │       │   │       └── +page.md
│   │   │       │   ├── rules/
│   │   │       │   │   └── +page.svelte
│   │   │       │   └── weir/
│   │   │       │       └── +page.md
│   │   │       ├── editor/
│   │   │       │   ├── +page.svelte
│   │   │       │   └── +page.ts
│   │   │       ├── install-browser-extension/
│   │   │       │   └── +page.svelte
│   │   │       ├── languagedetection/
│   │   │       │   └── +page.svelte
│   │   │       ├── latestversion/
│   │   │       │   └── +server.ts
│   │   │       ├── presentation/
│   │   │       │   └── +page.svelte
│   │   │       ├── report-problematic-lint/
│   │   │       │   └── +page.svelte
│   │   │       ├── request-browser-support/
│   │   │       │   └── +page.svelte
│   │   │       ├── stats/
│   │   │       │   └── +page.svelte
│   │   │       ├── titlecase/
│   │   │       │   └── +page.svelte
│   │   │       ├── uninstall-browser-extension/
│   │   │       │   └── +page.svelte
│   │   │       ├── weir/
│   │   │       │   └── studio/
│   │   │       │       └── +page.svelte
│   │   │       └── wpdemo/
│   │   │           └── +page.server.ts
│   │   ├── static/
│   │   │   ├── browserconfig.xml
│   │   │   └── site.webmanifest
│   │   ├── svelte.config.js
│   │   ├── tailwind.config.js
│   │   ├── tsconfig.json
│   │   └── vite.config.ts
│   └── wordpress-plugin/
│       ├── .editorconfig
│       ├── .gitignore
│       ├── README.md
│       ├── harper.php
│       ├── package.json
│       └── src/
│           └── harper/
│               ├── Box.ts
│               ├── DataBlock.ts
│               ├── DialectSelectRow.tsx
│               ├── Highlighter.tsx
│               ├── LintList.tsx
│               ├── LintListItem.tsx
│               ├── LintSettingList.tsx
│               ├── LintSettingRow.tsx
│               ├── LinterProvider.tsx
│               ├── Logo.jsx
│               ├── RichText.ts
│               ├── SidebarControl.tsx
│               ├── SidebarTabContainer.tsx
│               ├── SuggestionControl.tsx
│               ├── block.json
│               ├── domUtils.ts
│               ├── index.css
│               ├── index.tsx
│               ├── lintUtils.ts
│               ├── useDialect.ts
│               ├── useIgnoredLintState.ts
│               ├── useLintBoxes.ts
│               ├── useLintConfig.ts
│               ├── usePersonalDictionary.ts
│               └── useToggle.ts
├── pnpm-workspace.yaml
├── rust-toolchain.toml
├── rustfmt.toml
└── weir_rules/
    ├── AtLeasToLeast.weir
    ├── BelieveInPreposition.weir
    ├── BetterOffPhrase.weir
    ├── BluRayHyphen.weir
    ├── CauseItIsBecause.weir
    ├── ColdModalTypo.weir
    ├── DoubleCheckHyphen.weir
    ├── EachOthersPossessive.weir
    ├── EasyGoingCompoundAdjective.weir
    ├── ExistentialPluralAgreement.weir
    ├── ExitedExcitedContext.weir
    ├── FirstPersonModifierHyphen.weir
    ├── FullWithToOf.weir
    ├── HaveNegNoAny.weir
    ├── InAdjectiveMatter.weir
    ├── IntroCueCommaBeforeThanks.weir
    ├── IsBeenAuxSequence.weir
    ├── ItTimeAuxiliary.weir
    ├── KnowNothingVerb.weir
    ├── LookInto.weir
    ├── MakeupCompoundNoun.weir
    ├── OvertimeCompoundNoun.weir
    ├── PleasRequestVerb.weir
    ├── PostItNoteHyphen.weir
    ├── PrincipleToPrincipalRoleNoun.weir
    ├── RelayOnForRely.weir
    ├── SayTellYou.weir
    ├── SneakPeekPreview.weir
    ├── TheWhetherWeather.weir
    ├── ThereAfterCompound.weir
    ├── ThereMissingIsClause.weir
    ├── ThieveNoun.weir
    ├── ThinkKnowOff.weir
    ├── TomorrowPossessiveModifier.weir
    ├── WasComprisedOf.weir
    ├── WokVerbTypo.weir
    └── YourOutClauseAgreement.weir

SYMBOL INDEX (8803 symbols across 581 files)

FILE: fuzz/fuzz_targets/fuzz_harper_comment.rs
  type Language (line 8) | struct Language(String);
    method arbitrary (line 48) | fn arbitrary(u: &mut Unstructured<'a>) -> Result<Self> {
  constant LANGUAGES (line 10) | const LANGUAGES: [&str; 34] = [
  type Input (line 55) | struct Input {
    method arbitrary (line 61) | fn arbitrary(u: &mut Unstructured<'a>) -> Result<Self> {
    method arbitrary_take_rest (line 66) | fn arbitrary_take_rest(u: Unstructured<'a>) -> Result<Self> {

FILE: harper-asciidoc/src/lib.rs
  type AsciidocParser (line 6) | pub struct AsciidocParser {
    method node_condition (line 11) | fn node_condition(n: &Node) -> bool {
  method default (line 20) | fn default() -> Self {
  method parse (line 31) | fn parse(&self, source: &[char]) -> Vec<Token> {

FILE: harper-brill/src/lib.rs
  constant BRILL_TAGGER_SOURCE (line 9) | const BRILL_TAGGER_SOURCE: &str = include_str!("../trained_tagger_model....
  function uncached_brill_tagger (line 14) | fn uncached_brill_tagger() -> BrillTagger<FreqDict> {
  function brill_tagger (line 20) | pub fn brill_tagger() -> Arc<BrillTagger<FreqDict>> {
  constant BRILL_CHUNKER_SOURCE (line 24) | const BRILL_CHUNKER_SOURCE: &str = include_str!("../trained_chunker_mode...
  function uncached_brill_chunker (line 29) | fn uncached_brill_chunker() -> BrillChunker {
  function brill_chunker (line 35) | pub fn brill_chunker() -> Arc<BrillChunker> {
  constant BURN_CHUNKER_VOCAB (line 39) | const BURN_CHUNKER_VOCAB: &[u8; 627993] = include_bytes!("../finished_ch...
  constant BURN_CHUNKER_BIN (line 40) | const BURN_CHUNKER_BIN: &[u8; 806312] = include_bytes!("../finished_chun...
  function uncached_burn_chunker (line 46) | fn uncached_burn_chunker() -> CachedChunker<BurnChunkerCpu> {
  function burn_chunker (line 56) | pub fn burn_chunker() -> Rc<CachedChunker<BurnChunkerCpu>> {

FILE: harper-cli/src/annotate.rs
  type Annotation (line 9) | pub(super) struct Annotation {
    method into_label (line 20) | pub(super) fn into_label(
    method iter_labels_from_document (line 33) | pub(super) fn iter_labels_from_document<'inpt_id>(
    method iter_from_document (line 44) | fn iter_from_document(
  type AnnotationType (line 84) | pub(super) enum AnnotationType {
    method build_report (line 91) | pub(super) fn build_report<'input_id>(
    method get_title (line 110) | pub(super) fn get_title(&self) -> &'static str {
    method get_title_with_tags (line 120) | pub(super) fn get_title_with_tags(&self, tags: &[&str]) -> Cow<'static...
  type RandomColorIter (line 132) | struct RandomColorIter {
    method new (line 136) | fn new() -> Self {
  type Item (line 144) | type Item = Color;
  method next (line 145) | fn next(&mut self) -> Option<Self::Item> {
  function get_color_for_enum_variant (line 155) | fn get_color_for_enum_variant<T: IntoEnumIterator + PartialEq>(variant_t...
  function get_color_for_index (line 168) | fn get_color_for_index(idx_to_color: usize) -> Color {

FILE: harper-cli/src/input.rs
  type InputTrait (line 14) | pub(crate) trait InputTrait {
    method get_identifier (line 17) | fn get_identifier(&self) -> Cow<'_, str>;
  type AnyInput (line 24) | pub(crate) enum AnyInput {
    method from (line 35) | fn from(input_string: String) -> Self {
  method from (line 48) | fn from(input_string: String) -> Self {
  method from (line 57) | fn from(input_string: String) -> Self {

FILE: harper-cli/src/input/multi_input.rs
  type MultiInputTrait (line 11) | pub(crate) trait MultiInputTrait: InputTrait {
    method iter_inputs (line 17) | fn iter_inputs(&self) -> anyhow::Result<impl Iterator<Item = SingleInp...
    method iter_inputs (line 67) | fn iter_inputs(&self) -> anyhow::Result<impl Iterator<Item = SingleInp...
  type MultiInput (line 22) | pub(crate) enum MultiInput {
    method try_parse_string (line 29) | pub(crate) fn try_parse_string(input_string: &str) -> anyhow::Result<S...
  type DirInput (line 48) | pub(crate) struct DirInput {
    method iter_files (line 54) | pub(crate) fn iter_files(&self) -> anyhow::Result<impl Iterator<Item =...
  method get_identifier (line 72) | fn get_identifier(&self) -> Cow<'_, str> {

FILE: harper-cli/src/input/single_input.rs
  type SingleInputTrait (line 24) | pub(crate) trait SingleInputTrait: InputTrait {
    method load (line 27) | fn load(
    method load_with_parser (line 38) | fn load_with_parser(
    method get_parser (line 48) | fn get_parser(&self, _markdown_options: MarkdownOptions) -> Box<dyn Pa...
    method get_content (line 53) | fn get_content(&self) -> anyhow::Result<Cow<'_, str>>;
    method get_content (line 131) | fn get_content(&self) -> anyhow::Result<Cow<'_, str>> {
    method get_parser (line 136) | fn get_parser(&self, _markdown_options: MarkdownOptions) -> Box<dyn Pa...
    method get_content (line 181) | fn get_content(&self) -> anyhow::Result<Cow<'_, str>> {
    method get_content (line 195) | fn get_content(&self) -> anyhow::Result<Cow<'_, str>> {
  type SingleInput (line 58) | pub(crate) enum SingleInput {
    method parse_string (line 72) | pub(crate) fn parse_string(input_string: &str) -> Self {
  type SingleInputOptionExt (line 85) | pub trait SingleInputOptionExt {
    method unwrap_or_read_from_stdin (line 87) | fn unwrap_or_read_from_stdin(self) -> SingleInput;
    method unwrap_or_read_from_stdin (line 90) | fn unwrap_or_read_from_stdin(self) -> SingleInput {
  type FileInput (line 97) | pub(crate) struct FileInput {
    method path (line 102) | pub(crate) fn path(&self) -> &PathBuf {
    method try_from_path (line 108) | pub(crate) fn try_from_path(path: &Path) -> anyhow::Result<Self> {
    method from_path_unchecked (line 123) | pub(crate) fn from_path_unchecked(path: &Path) -> Self {
  method get_identifier (line 168) | fn get_identifier(&self) -> Cow<'_, str> {
  type TextInput (line 177) | pub(crate) struct TextInput {
  method get_identifier (line 186) | fn get_identifier(&self) -> Cow<'_, str> {
  type StdinInput (line 193) | pub(crate) struct StdinInput;
  method get_identifier (line 202) | fn get_identifier(&self) -> Cow<'_, str> {

FILE: harper-cli/src/lint.rs
  function load_dict (line 28) | fn load_dict(path: &Path) -> anyhow::Result<MutableDictionary> {
  function load_weirpacks (line 40) | fn load_weirpacks(inputs: &[SingleInput]) -> anyhow::Result<Vec<Weirpack...
  function file_dict_name (line 61) | fn file_dict_name(path: &Path) -> PathBuf {
  type OutputFormat (line 76) | pub enum OutputFormat {
  type LintOptions (line 86) | pub struct LintOptions {
  type ReportStyle (line 97) | enum ReportStyle {
  type JsonFileResult (line 105) | struct JsonFileResult {
  type JsonLint (line 114) | struct JsonLint {
  type JsonSpan (line 128) | struct JsonSpan {
  function char_index_to_line_col (line 134) | fn char_index_to_line_col(source: &[char], index: usize) -> (usize, usiz...
  type InputInfo (line 141) | struct InputInfo<'a> {
  type InputJob (line 147) | struct InputJob {
  function plain_path (line 155) | fn plain_path(&self) -> String {
  function format_path (line 164) | fn format_path(&self) -> String {
  function lint (line 178) | pub fn lint(
  type LintOneResult (line 365) | struct LintOneResult {
  type FullInputInfo (line 373) | struct FullInputInfo<'a> {
  function lint_one_input (line 380) | fn lint_one_input(
  function configure_lint_group (line 537) | fn configure_lint_group(
  function count_lint_kinds_and_rules (line 564) | fn count_lint_kinds_and_rules(
  function collect_lint_kind_rule_pairs (line 583) | fn collect_lint_kind_rule_pairs(
  function collect_spellos (line 600) | fn collect_spellos(
  function single_input_report (line 615) | fn single_input_report(
  function find_longest_doc_line (line 750) | fn find_longest_doc_line(toks: &[Token]) -> usize {
  function final_report (line 781) | fn final_report(
  function lint_kind_to_rgb (line 912) | fn lint_kind_to_rgb() -> &'static [(LintKind, (u8, u8, u8))] {
  function rgb_for_lint_kind (line 937) | fn rgb_for_lint_kind(olk: Option<&LintKind>) -> (u8, u8, u8) {
  function print_formatted_items (line 947) | fn print_formatted_items(items: impl IntoIterator<Item = (Option<String>...

FILE: harper-cli/src/main.rs
  type Cli (line 46) | struct Cli {
  type Args (line 56) | enum Args {
  function main (line 231) | fn main() -> anyhow::Result<()> {
  function parse_dialect (line 1004) | fn parse_dialect(dialect: &str) -> anyhow::Result<Dialect> {
  function line_to_parts (line 1016) | fn line_to_parts(line: &str) -> (String, String) {
  function print_word_derivations (line 1024) | fn print_word_derivations(word: &str, annot: &str, dictionary: &impl Dic...

FILE: harper-cli/tests/no_color.rs
  function harper_cli (line 3) | fn harper_cli() -> Command {
  constant BAD_INPUT (line 8) | const BAD_INPUT: &str = "This is an test.";
  function has_ansi (line 10) | fn has_ansi(bytes: &[u8]) -> bool {
  function default_output_contains_ansi (line 15) | fn default_output_contains_ansi() {
  function no_color_flag_strips_ansi (line 30) | fn no_color_flag_strips_ansi() {
  function no_color_env_strips_ansi (line 45) | fn no_color_env_strips_ansi() {

FILE: harper-cli/tests/output_format.rs
  function harper_cli (line 4) | fn harper_cli() -> Command {
  constant BAD_INPUT (line 9) | const BAD_INPUT: &str = "This is an test.";
  function json_format_is_valid_json (line 12) | fn json_format_is_valid_json() {
  function json_format_no_ansi (line 52) | fn json_format_no_ansi() {
  function json_directory_paths_no_ansi (line 77) | fn json_directory_paths_no_ansi() {
  function compact_directory_paths_no_ansi (line 109) | fn compact_directory_paths_no_ansi() {
  function compact_format_one_line_per_lint (line 132) | fn compact_format_one_line_per_lint() {
  function default_format_unchanged (line 156) | fn default_format_unchanged() {

FILE: harper-comments/src/comment_parser.rs
  type CommentParser (line 12) | pub struct CommentParser {
    method create_ident_dict (line 17) | pub fn create_ident_dict(&self, source: &[char]) -> Option<MutableDict...
    method new_from_language_id (line 21) | pub fn new_from_language_id(
    method new_from_filename (line 77) | pub fn new_from_filename(filename: &Path, markdown_options: MarkdownOp...
    method filename_to_filetype (line 86) | fn filename_to_filetype(path: &Path) -> Option<&'static str> {
    method node_condition (line 120) | fn node_condition(n: &Node) -> bool {
  method parse (line 126) | fn parse(&self, source: &[char]) -> Vec<Token> {
  function hang (line 137) | fn hang() {

FILE: harper-comments/src/comment_parsers/go.rs
  type Go (line 8) | pub struct Go {
    method new (line 13) | pub fn new(parser: Lrc<dyn Parser>) -> Self {
    method new_markdown (line 17) | pub fn new_markdown(markdown_options: MarkdownOptions) -> Self {
  method parse (line 23) | fn parse(&self, source: &[char]) -> Vec<Token> {

FILE: harper-comments/src/comment_parsers/javadoc.rs
  type JavaDoc (line 10) | pub struct JavaDoc {
  method parse (line 15) | fn parse(&self, source: &[char]) -> Vec<Token> {

FILE: harper-comments/src/comment_parsers/jsdoc.rs
  type JsDoc (line 9) | pub struct JsDoc {
    method new (line 14) | pub fn new(parser: Lrc<dyn Parser>) -> Self {
    method new_markdown (line 18) | pub fn new_markdown(markdown_options: MarkdownOptions) -> Self {
  method parse (line 24) | fn parse(&self, source: &[char]) -> Vec<Token> {
  function parse_line (line 51) | fn parse_line(source: &[char], parser: Lrc<dyn Parser>) -> Vec<Token> {
  function mark_inline_tags (line 94) | pub(super) fn mark_inline_tags(tokens: &mut [Token]) {
  function parse_inline_tag (line 126) | fn parse_inline_tag(tokens: &[Token]) -> Option<usize> {
  function escapes_loop (line 176) | fn escapes_loop() {
  function handles_inline_link (line 184) | fn handles_inline_link() {
  function handles_class (line 229) | fn handles_class() {

FILE: harper-comments/src/comment_parsers/lua.rs
  type Lua (line 9) | pub struct Lua {
    method new (line 14) | pub fn new(parser: Lrc<dyn Parser>) -> Self {
    method new_markdown (line 18) | pub fn new_markdown(markdown_options: MarkdownOptions) -> Self {
  method parse (line 24) | fn parse(&self, source: &[char]) -> Vec<Token> {
  function starts_with_prefix (line 60) | fn starts_with_prefix(source: &[char]) -> bool {
  function parse_line (line 67) | fn parse_line(source: &[char], parser: Lrc<dyn Parser>) -> Vec<Token> {

FILE: harper-comments/src/comment_parsers/mod.rs
  function without_initiators (line 18) | fn without_initiators(source: &[char]) -> Span<char> {
  function is_comment_character (line 36) | fn is_comment_character(c: char) -> bool {
  function cleans_empty_comment (line 45) | fn cleans_empty_comment() {
  function cleans_empty_comment_with_whitespace (line 51) | fn cleans_empty_comment_with_whitespace() {

FILE: harper-comments/src/comment_parsers/solidity.rs
  type Solidity (line 10) | pub struct Solidity {
    method new (line 15) | pub fn new(parser: Lrc<dyn Parser>) -> Self {
    method new_markdown (line 19) | pub fn new_markdown(markdown_options: MarkdownOptions) -> Self {
  method parse (line 25) | fn parse(&self, source: &[char]) -> Vec<Token> {
  function parse_line (line 52) | fn parse_line(source: &[char], parser: Lrc<dyn Parser>) -> Vec<Token> {

FILE: harper-comments/src/comment_parsers/unit.rs
  type Unit (line 14) | pub struct Unit {
    method new (line 19) | pub fn new(parser: Lrc<dyn Parser>) -> Self {
    method new_markdown (line 23) | pub fn new_markdown(markdown_options: MarkdownOptions) -> Self {
  method parse (line 29) | fn parse(&self, source: &[char]) -> Vec<Token> {
  function parse_line (line 66) | fn parse_line(source: &[char], parser: Lrc<dyn Parser>) -> Vec<Token> {
  function line_is_code_fence (line 84) | fn line_is_code_fence(source: &[char]) -> bool {

FILE: harper-comments/src/masker.rs
  type CommentMasker (line 5) | pub struct CommentMasker {
    method create_ident_dict (line 11) | pub fn create_ident_dict(&self, source: &[char]) -> Option<MutableDict...
    method new (line 15) | pub fn new(
    method new_with_ignore_condition (line 36) | pub fn new_with_ignore_condition(
  method create_mask (line 49) | fn create_mask(&self, source: &[char]) -> harper_core::Mask {

FILE: harper-comments/tests/language_support_sources/clean.rs
  type TestStruct (line 3) | struct TestStruct {}
    method test_function (line 8) | fn test_function() {}
    method test_function (line 12) | fn test_function() {}

FILE: harper-comments/tests/language_support_sources/eof.rs
  function main (line 1) | fn main() {}

FILE: harper-comments/tests/language_support_sources/ignore_comments.c
  function main (line 2) | int main() {

FILE: harper-comments/tests/language_support_sources/ignore_comments.rs
  type Testing (line 5) | pub struct Testing {

FILE: harper-comments/tests/language_support_sources/issue_132.rs
  function main (line 6) | fn main() {

FILE: harper-comments/tests/language_support_sources/javadoc_clean_simple.java
  class TestClass (line 1) | class TestClass {
    method main (line 6) | public static void main(String[] args) {

FILE: harper-comments/tests/language_support_sources/javadoc_complex.java
  class TestClass (line 1) | class TestClass {
    method main (line 15) | public static void main(String[] args) {
    method greet (line 24) | public static void greet(String name) {

FILE: harper-comments/tests/language_support_sources/jsdoc.ts
  function test (line 3) | function test(){}
  class Clazz (line 7) | class Clazz { }
  function foo (line 24) | function foo(n, o, d) {

FILE: harper-comments/tests/language_support_sources/multiline_comments.cpp
  function test (line 3) | int test() {}
  function arbitrary (line 10) | int arbitrary() {}

FILE: harper-comments/tests/language_support_sources/multiline_comments.ts
  function test (line 3) | function test() {}
  function arbitrary (line 10) | function arbitrary() {}

FILE: harper-core/benches/parse_essay.rs
  function parse_essay (line 9) | fn parse_essay(c: &mut Criterion) {
  function lint_essay (line 15) | fn lint_essay(c: &mut Criterion) {
  function lint_essay_uncached (line 25) | fn lint_essay_uncached(c: &mut Criterion) {
  function criterion_benchmark (line 36) | pub fn criterion_benchmark(c: &mut Criterion) {

FILE: harper-core/build.rs
  function main (line 3) | fn main() {

FILE: harper-core/src/case.rs
  function copy_casing (line 14) | pub fn copy_casing(
  type Case (line 38) | pub enum Case {
    method apply_to (line 49) | pub fn apply_to(&self, char: char) -> impl Iterator<Item = char> + use...
    type Error (line 59) | type Error = ();
    method try_from (line 64) | fn try_from(value: char) -> Result<Self, Self::Error> {
  type CaseIterExt (line 77) | pub trait CaseIterExt {
    method get_casing (line 78) | fn get_casing(self) -> impl Iterator<Item = Case>;
    method get_casing_unfiltered (line 79) | fn get_casing_unfiltered(self) -> SmallVec<[Option<Case>; CHAR_STRING_...
    method get_casing (line 84) | fn get_casing(self) -> impl Iterator<Item = Case> {
    method get_casing_unfiltered (line 92) | fn get_casing_unfiltered(self) -> SmallVec<[Option<Case>; CHAR_STRING_...

FILE: harper-core/src/char_ext.rs
  type Sealed (line 7) | pub trait Sealed {}
  type CharExt (line 12) | pub trait CharExt: private::Sealed {
    method is_cjk (line 13) | fn is_cjk(&self) -> bool;
    method is_english_lingual (line 15) | fn is_english_lingual(&self) -> bool;
    method is_emoji (line 16) | fn is_emoji(&self) -> bool;
    method is_punctuation (line 17) | fn is_punctuation(&self) -> bool;
    method is_vowel (line 21) | fn is_vowel(&self) -> bool;
    method normalized (line 22) | fn normalized(&self) -> Self;
    method is_english_lingual (line 26) | fn is_english_lingual(&self) -> bool {
    method normalized (line 37) | fn normalized(&self) -> Self {
    method is_emoji (line 46) | fn is_emoji(&self) -> bool {
    method is_cjk (line 62) | fn is_cjk(&self) -> bool {
    method is_punctuation (line 97) | fn is_punctuation(&self) -> bool {
    method is_vowel (line 101) | fn is_vowel(&self) -> bool {
  function cjk_is_not_english_lingual (line 111) | fn cjk_is_not_english_lingual() {

FILE: harper-core/src/char_string.rs
  constant CHAR_STRING_INLINE_SIZE (line 7) | pub(crate) const CHAR_STRING_INLINE_SIZE: usize = 16;
  type CharString (line 11) | pub type CharString = SmallVec<[char; CHAR_STRING_INLINE_SIZE]>;
  type Sealed (line 14) | pub trait Sealed {}
  type CharStringExt (line 20) | pub trait CharStringExt: private::Sealed {
    method to_lower (line 22) | fn to_lower(&'_ self) -> Cow<'_, [char]>;
    method normalized (line 25) | fn normalized(&'_ self) -> Cow<'_, [char]>;
    method to_string (line 28) | fn to_string(&self) -> String;
    method eq_ignore_ascii_case_chars (line 32) | fn eq_ignore_ascii_case_chars(&self, other: &[char]) -> bool;
    method eq_ignore_ascii_case_str (line 36) | fn eq_ignore_ascii_case_str(&self, other: &str) -> bool;
    method eq_any_ignore_ascii_case_str (line 40) | fn eq_any_ignore_ascii_case_str(&self, others: &[&str]) -> bool;
    method eq_any_ignore_ascii_case_chars (line 44) | fn eq_any_ignore_ascii_case_chars(&self, others: &[&[char]]) -> bool;
    method starts_with_ignore_ascii_case_str (line 48) | fn starts_with_ignore_ascii_case_str(&self, prefix: &str) -> bool;
    method starts_with_any_ignore_ascii_case_str (line 52) | fn starts_with_any_ignore_ascii_case_str(&self, prefixes: &[&str]) -> ...
    method ends_with_ignore_ascii_case_chars (line 56) | fn ends_with_ignore_ascii_case_chars(&self, suffix: &[char]) -> bool;
    method ends_with_ignore_ascii_case_str (line 60) | fn ends_with_ignore_ascii_case_str(&self, suffix: &str) -> bool;
    method ends_with_any_ignore_ascii_case_chars (line 64) | fn ends_with_any_ignore_ascii_case_chars(&self, suffixes: &[&[char]]) ...
    method contains_vowel (line 67) | fn contains_vowel(&self) -> bool;
    method to_lower (line 71) | fn to_lower(&'_ self) -> Cow<'_, [char]> {
    method to_string (line 83) | fn to_string(&self) -> String {
    method normalized (line 89) | fn normalized(&'_ self) -> Cow<'_, [char]> {
    method eq_ignore_ascii_case_str (line 103) | fn eq_ignore_ascii_case_str(&self, other: &str) -> bool {
    method eq_ignore_ascii_case_chars (line 121) | fn eq_ignore_ascii_case_chars(&self, other: &[char]) -> bool {
    method eq_any_ignore_ascii_case_str (line 129) | fn eq_any_ignore_ascii_case_str(&self, others: &[&str]) -> bool {
    method eq_any_ignore_ascii_case_chars (line 133) | fn eq_any_ignore_ascii_case_chars(&self, others: &[&[char]]) -> bool {
    method starts_with_ignore_ascii_case_str (line 139) | fn starts_with_ignore_ascii_case_str(&self, prefix: &str) -> bool {
    method starts_with_any_ignore_ascii_case_str (line 150) | fn starts_with_any_ignore_ascii_case_str(&self, prefixes: &[&str]) -> ...
    method ends_with_ignore_ascii_case_str (line 156) | fn ends_with_ignore_ascii_case_str(&self, suffix: &str) -> bool {
    method ends_with_ignore_ascii_case_chars (line 169) | fn ends_with_ignore_ascii_case_chars(&self, suffix: &[char]) -> bool {
    method ends_with_any_ignore_ascii_case_chars (line 182) | fn ends_with_any_ignore_ascii_case_chars(&self, suffixes: &[&[char]]) ...
    method contains_vowel (line 188) | fn contains_vowel(&self) -> bool {
  function eq_ignore_ascii_case_chars_matches_lowercase (line 208) | fn eq_ignore_ascii_case_chars_matches_lowercase() {
  function eq_ignore_ascii_case_chars_does_not_match_different_word (line 213) | fn eq_ignore_ascii_case_chars_does_not_match_different_word() {
  function eq_ignore_ascii_case_str_matches_lowercase (line 218) | fn eq_ignore_ascii_case_str_matches_lowercase() {
  function eq_ignore_ascii_case_str_does_not_match_different_word (line 223) | fn eq_ignore_ascii_case_str_does_not_match_different_word() {
  function ends_with_ignore_ascii_case_chars_matches_suffix (line 228) | fn ends_with_ignore_ascii_case_chars_matches_suffix() {
  function ends_with_ignore_ascii_case_chars_does_not_match_different_suffix (line 233) | fn ends_with_ignore_ascii_case_chars_does_not_match_different_suffix() {
  function ends_with_ignore_ascii_case_str_matches_suffix (line 241) | fn ends_with_ignore_ascii_case_str_matches_suffix() {
  function ends_with_ignore_ascii_case_str_does_not_match_different_suffix (line 246) | fn ends_with_ignore_ascii_case_str_does_not_match_different_suffix() {
  function differs_only_by_length_1 (line 251) | fn differs_only_by_length_1() {
  function differs_only_by_length_2 (line 256) | fn differs_only_by_length_2() {

FILE: harper-core/src/currency.rs
  type Currency (line 8) | pub enum Currency {
    method from_char (line 34) | pub fn from_char(c: char) -> Option<Self> {
    method to_char (line 53) | pub fn to_char(&self) -> char {
    method format_amount (line 70) | pub fn format_amount(&self, amount: &Number) -> String {

FILE: harper-core/src/dict_word_metadata.rs
  type DictWordMetadata (line 20) | pub struct DictWordMetadata {
    method infer_pos_tag (line 132) | pub fn infer_pos_tag(&self) -> Option<UPOS> {
    method or (line 187) | pub fn or(&self, other: &Self) -> Self {
    method enforce_pos_exclusivity (line 200) | pub fn enforce_pos_exclusivity(&mut self, pos: &UPOS) {
    method get_person (line 396) | pub fn get_person(&self) -> Option<Person> {
    method is_first_person_plural_pronoun (line 400) | pub fn is_first_person_plural_pronoun(&self) -> bool {
    method is_first_person_singular_pronoun (line 411) | pub fn is_first_person_singular_pronoun(&self) -> bool {
    method is_third_person_plural_pronoun (line 422) | pub fn is_third_person_plural_pronoun(&self) -> bool {
    method is_third_person_singular_pronoun (line 433) | pub fn is_third_person_singular_pronoun(&self) -> bool {
    method is_third_person_pronoun (line 444) | pub fn is_third_person_pronoun(&self) -> bool {
    method is_second_person_pronoun (line 454) | pub fn is_second_person_pronoun(&self) -> bool {
    method is_verb_lemma (line 465) | pub fn is_verb_lemma(&self) -> bool {
    method is_verb_past_form (line 476) | pub fn is_verb_past_form(&self) -> bool {
    method is_verb_simple_past_form (line 483) | pub fn is_verb_simple_past_form(&self) -> bool {
    method is_verb_past_participle_form (line 490) | pub fn is_verb_past_participle_form(&self) -> bool {
    method is_verb_progressive_form (line 497) | pub fn is_verb_progressive_form(&self) -> bool {
    method is_verb_third_person_singular_present_form (line 504) | pub fn is_verb_third_person_singular_present_form(&self) -> bool {
    method is_singular_noun (line 514) | pub fn is_singular_noun(&self) -> bool {
    method is_non_singular_noun (line 524) | pub fn is_non_singular_noun(&self) -> bool {
    method is_countable_noun (line 536) | pub fn is_countable_noun(&self) -> bool {
    method is_non_countable_noun (line 546) | pub fn is_non_countable_noun(&self) -> bool {
    method is_mass_noun_only (line 558) | pub fn is_mass_noun_only(&self) -> bool {
    method is_nominal (line 572) | pub fn is_nominal(&self) -> bool {
    method is_singular_nominal (line 577) | pub fn is_singular_nominal(&self) -> bool {
    method is_plural_nominal (line 582) | pub fn is_plural_nominal(&self) -> bool {
    method is_possessive_nominal (line 590) | pub fn is_possessive_nominal(&self) -> bool {
    method is_non_singular_nominal (line 595) | pub fn is_non_singular_nominal(&self) -> bool {
    method is_non_plural_nominal (line 600) | pub fn is_non_plural_nominal(&self) -> bool {
    method get_degree (line 606) | pub fn get_degree(&self) -> Option<Degree> {
    method is_comparative_adjective (line 610) | pub fn is_comparative_adjective(&self) -> bool {
    method is_superlative_adjective (line 619) | pub fn is_superlative_adjective(&self) -> bool {
    method is_positive_adjective (line 629) | pub fn is_positive_adjective(&self) -> bool {
    method is_quantifier (line 645) | pub fn is_quantifier(&self) -> bool {
    method is_swear (line 652) | pub fn is_swear(&self) -> bool {
    method is_lowercase (line 663) | pub fn is_lowercase(&self) -> bool {
    method is_titlecase (line 677) | pub fn is_titlecase(&self) -> bool {
    method is_allcaps (line 687) | pub fn is_allcaps(&self) -> bool {
    method is_lower_camel (line 701) | pub fn is_lower_camel(&self) -> bool {
    method is_upper_camel (line 720) | pub fn is_upper_camel(&self) -> bool {
    method is_apostrophized (line 725) | pub fn is_apostrophized(&self) -> bool {
    method is_roman_numerals (line 729) | pub fn is_roman_numerals(&self) -> bool {
    method merge (line 734) | pub fn merge(&mut self, other: &Self) -> &mut Self {
  function default_false (line 59) | fn default_false() -> bool {
  function default_none (line 64) | fn default_none<T>() -> Option<T> {
  function default_default (line 69) | fn default_default<T: Default>() -> T {
  type VerbForm (line 783) | pub enum VerbForm {
  type VerbFormFlagsUnderlyingType (line 799) | pub type VerbFormFlagsUnderlyingType = u32;
  type VerbData (line 818) | pub struct VerbData {
    method or (line 827) | pub fn or(&self, other: &Self) -> Self {
  type NounData (line 848) | pub struct NounData {
    method or (line 859) | pub fn or(&self, other: &Self) -> Self {
  type Person (line 873) | pub enum Person {
  type PronounData (line 881) | pub struct PronounData {
    method or (line 894) | pub fn or(&self, other: &Self) -> Self {
  type DeterminerData (line 910) | pub struct DeterminerData {
    method or (line 918) | pub fn or(&self, other: &Self) -> Self {
  type Degree (line 931) | pub enum Degree {
  type AdjectiveData (line 941) | pub struct AdjectiveData {
    method or (line 947) | pub fn or(&self, other: &Self) -> Self {
  type AdverbData (line 958) | pub struct AdverbData {
    method or (line 966) | pub fn or(&self, _other: &Self) -> Self {
  type ConjunctionData (line 976) | pub struct ConjunctionData {}
    method or (line 980) | pub fn or(&self, _other: &Self) -> Self {
  type AffixData (line 986) | pub struct AffixData {
    method or (line 993) | pub fn or(&self, _other: &Self) -> Self {
  type Dialect (line 1022) | pub enum Dialect {
    method try_guess_from_document (line 1033) | pub fn try_guess_from_document(document: &Document) -> Option<Self> {
    method try_from_abbr (line 1055) | pub fn try_from_abbr(abbr: &str) -> Option<Self> {
    type Error (line 1067) | type Error = ();
    method try_from (line 1075) | fn try_from(dialect_flags: DialectFlags) -> Result<Self, Self::Error> {
  type DialectFlagsUnderlyingType (line 1096) | type DialectFlagsUnderlyingType = u8;
  method is_dialect_enabled (line 1116) | pub fn is_dialect_enabled(self, dialect: Dialect) -> bool {
  method is_dialect_enabled_strict (line 1125) | pub fn is_dialect_enabled_strict(self, dialect: Dialect) -> bool {
  method from_dialect (line 1137) | pub fn from_dialect(dialect: Dialect) -> Self {
  method get_most_used_dialects_from_document (line 1150) | pub fn get_most_used_dialects_from_document(document: &Document) -> Self {
  method default (line 1190) | fn default() -> Self {
  function md (line 1201) | pub fn md(word: &str) -> DictWordMetadata {
  function guess_british_dialect (line 1213) | fn guess_british_dialect() {
  function guess_american_dialect (line 1223) | fn guess_american_dialect() {
  function puppy_is_noun (line 1237) | fn puppy_is_noun() {
  function prepare_is_not_noun (line 1242) | fn prepare_is_not_noun() {
  function paris_is_proper_noun (line 1247) | fn paris_is_proper_noun() {
  function permit_is_non_proper_noun (line 1252) | fn permit_is_non_proper_noun() {
  function hound_is_singular_noun (line 1257) | fn hound_is_singular_noun() {
  function pooches_is_non_singular_noun (line 1262) | fn pooches_is_non_singular_noun() {
  function loyal_doesnt_pass_is_non_singular_noun (line 1270) | fn loyal_doesnt_pass_is_non_singular_noun() {
  function hounds_is_plural_noun (line 1275) | fn hounds_is_plural_noun() {
  function pooch_is_non_plural_noun (line 1280) | fn pooch_is_non_plural_noun() {
  function fish_is_singular_noun (line 1285) | fn fish_is_singular_noun() {
  function fish_is_plural_noun (line 1290) | fn fish_is_plural_noun() {
  function fishes_is_plural_noun (line 1295) | fn fishes_is_plural_noun() {
  function sheep_is_singular_noun (line 1300) | fn sheep_is_singular_noun() {
  function sheep_is_plural_noun (line 1305) | fn sheep_is_plural_noun() {
  function sheeps_is_not_word (line 1311) | fn sheeps_is_not_word() {
  function bicep_is_singular_noun (line 1316) | fn bicep_is_singular_noun() {
  function biceps_is_singular_noun (line 1321) | fn biceps_is_singular_noun() {
  function biceps_is_plural_noun (line 1326) | fn biceps_is_plural_noun() {
  function aircraft_is_singular_noun (line 1331) | fn aircraft_is_singular_noun() {
  function aircraft_is_plural_noun (line 1336) | fn aircraft_is_plural_noun() {
  function aircrafts_is_not_word (line 1342) | fn aircrafts_is_not_word() {
  function dog_apostrophe_s_is_possessive_noun (line 1347) | fn dog_apostrophe_s_is_possessive_noun() {
  function dogs_is_non_possessive_noun (line 1352) | fn dogs_is_non_possessive_noun() {
  function dog_is_countable (line 1359) | fn dog_is_countable() {
  function dog_is_non_mass_noun (line 1363) | fn dog_is_non_mass_noun() {
  function furniture_is_mass_noun (line 1368) | fn furniture_is_mass_noun() {
  function furniture_is_non_countable_noun (line 1372) | fn furniture_is_non_countable_noun() {
  function equipment_is_mass_noun (line 1377) | fn equipment_is_mass_noun() {
  function equipment_is_non_countable_noun (line 1381) | fn equipment_is_non_countable_noun() {
  function beer_is_countable_noun (line 1386) | fn beer_is_countable_noun() {
  function beer_is_mass_noun (line 1390) | fn beer_is_mass_noun() {
  function i_is_pronoun (line 1402) | fn i_is_pronoun() {
  function i_is_personal_pronoun (line 1406) | fn i_is_personal_pronoun() {
  function i_is_singular_pronoun (line 1410) | fn i_is_singular_pronoun() {
  function i_is_subject_pronoun (line 1414) | fn i_is_subject_pronoun() {
  function me_is_pronoun (line 1419) | fn me_is_pronoun() {
  function me_is_personal_pronoun (line 1423) | fn me_is_personal_pronoun() {
  function me_is_singular_pronoun (line 1427) | fn me_is_singular_pronoun() {
  function me_is_object_pronoun (line 1431) | fn me_is_object_pronoun() {
  function myself_is_pronoun (line 1436) | fn myself_is_pronoun() {
  function myself_is_personal_pronoun (line 1440) | fn myself_is_personal_pronoun() {
  function myself_is_singular_pronoun (line 1444) | fn myself_is_singular_pronoun() {
  function myself_is_reflexive_pronoun (line 1448) | fn myself_is_reflexive_pronoun() {
  function we_is_pronoun (line 1457) | fn we_is_pronoun() {
  function we_is_personal_pronoun (line 1461) | fn we_is_personal_pronoun() {
  function we_is_plural_pronoun (line 1465) | fn we_is_plural_pronoun() {
  function we_is_subject_pronoun (line 1469) | fn we_is_subject_pronoun() {
  function us_is_pronoun (line 1474) | fn us_is_pronoun() {
  function us_is_personal_pronoun (line 1478) | fn us_is_personal_pronoun() {
  function us_is_plural_pronoun (line 1482) | fn us_is_plural_pronoun() {
  function us_is_object_pronoun (line 1486) | fn us_is_object_pronoun() {
  function ourselves_is_pronoun (line 1491) | fn ourselves_is_pronoun() {
  function ourselves_is_personal_pronoun (line 1495) | fn ourselves_is_personal_pronoun() {
  function ourselves_is_plural_pronoun (line 1499) | fn ourselves_is_plural_pronoun() {
  function ourselves_is_reflexive_pronoun (line 1503) | fn ourselves_is_reflexive_pronoun() {
  function you_is_pronoun (line 1512) | fn you_is_pronoun() {
  function you_is_personal_pronoun (line 1516) | fn you_is_personal_pronoun() {
  function you_is_singular_pronoun (line 1520) | fn you_is_singular_pronoun() {
  function you_is_plural_pronoun (line 1524) | fn you_is_plural_pronoun() {
  function you_is_subject_pronoun (line 1528) | fn you_is_subject_pronoun() {
  function you_is_object_pronoun (line 1532) | fn you_is_object_pronoun() {
  function yourself_is_pronoun (line 1536) | fn yourself_is_pronoun() {
  function yourself_is_personal_pronoun (line 1540) | fn yourself_is_personal_pronoun() {
  function yourself_is_singular_pronoun (line 1544) | fn yourself_is_singular_pronoun() {
  function yourself_is_reflexive_pronoun (line 1548) | fn yourself_is_reflexive_pronoun() {
  function he_is_pronoun (line 1557) | fn he_is_pronoun() {
  function he_is_personal_pronoun (line 1561) | fn he_is_personal_pronoun() {
  function he_is_singular_pronoun (line 1565) | fn he_is_singular_pronoun() {
  function he_is_subject_pronoun (line 1569) | fn he_is_subject_pronoun() {
  function him_is_pronoun (line 1574) | fn him_is_pronoun() {
  function him_is_personal_pronoun (line 1578) | fn him_is_personal_pronoun() {
  function him_is_singular_pronoun (line 1582) | fn him_is_singular_pronoun() {
  function him_is_object_pronoun (line 1586) | fn him_is_object_pronoun() {
  function himself_is_pronoun (line 1591) | fn himself_is_pronoun() {
  function himself_is_personal_pronoun (line 1595) | fn himself_is_personal_pronoun() {
  function himself_is_singular_pronoun (line 1599) | fn himself_is_singular_pronoun() {
  function himself_is_reflexive_pronoun (line 1603) | fn himself_is_reflexive_pronoun() {
  function she_is_pronoun (line 1612) | fn she_is_pronoun() {
  function she_is_personal_pronoun (line 1616) | fn she_is_personal_pronoun() {
  function she_is_singular_pronoun (line 1620) | fn she_is_singular_pronoun() {
  function she_is_subject_pronoun (line 1624) | fn she_is_subject_pronoun() {
  function her_is_pronoun (line 1629) | fn her_is_pronoun() {
  function her_is_personal_pronoun (line 1633) | fn her_is_personal_pronoun() {
  function her_is_singular_pronoun (line 1637) | fn her_is_singular_pronoun() {
  function her_is_object_pronoun (line 1641) | fn her_is_object_pronoun() {
  function herself_is_pronoun (line 1646) | fn herself_is_pronoun() {
  function herself_is_personal_pronoun (line 1650) | fn herself_is_personal_pronoun() {
  function herself_is_singular_pronoun (line 1654) | fn herself_is_singular_pronoun() {
  function herself_is_reflexive_pronoun (line 1658) | fn herself_is_reflexive_pronoun() {
  function it_is_pronoun (line 1667) | fn it_is_pronoun() {
  function it_is_personal_pronoun (line 1671) | fn it_is_personal_pronoun() {
  function it_is_singular_pronoun (line 1675) | fn it_is_singular_pronoun() {
  function it_is_subject_pronoun (line 1679) | fn it_is_subject_pronoun() {
  function it_is_object_pronoun (line 1683) | fn it_is_object_pronoun() {
  function itself_is_pronoun (line 1688) | fn itself_is_pronoun() {
  function itself_is_personal_pronoun (line 1692) | fn itself_is_personal_pronoun() {
  function itself_is_singular_pronoun (line 1696) | fn itself_is_singular_pronoun() {
  function itself_is_reflexive_pronoun (line 1700) | fn itself_is_reflexive_pronoun() {
  function they_is_pronoun (line 1709) | fn they_is_pronoun() {
  function they_is_personal_pronoun (line 1713) | fn they_is_personal_pronoun() {
  function they_is_plural_pronoun (line 1717) | fn they_is_plural_pronoun() {
  function they_is_subject_pronoun (line 1721) | fn they_is_subject_pronoun() {
  function them_is_pronoun (line 1726) | fn them_is_pronoun() {
  function them_is_personal_pronoun (line 1730) | fn them_is_personal_pronoun() {
  function them_is_plural_pronoun (line 1734) | fn them_is_plural_pronoun() {
  function them_is_object_pronoun (line 1738) | fn them_is_object_pronoun() {
  function themselves_is_pronoun (line 1743) | fn themselves_is_pronoun() {
  function themselves_is_personal_pronoun (line 1747) | fn themselves_is_personal_pronoun() {
  function themselves_is_plural_pronoun (line 1751) | fn themselves_is_plural_pronoun() {
  function themselves_is_reflexive_pronoun (line 1755) | fn themselves_is_reflexive_pronoun() {
  function mine_is_pronoun (line 1762) | fn mine_is_pronoun() {
  function ours_is_pronoun (line 1766) | fn ours_is_pronoun() {
  function yours_is_pronoun (line 1770) | fn yours_is_pronoun() {
  function his_is_pronoun (line 1774) | fn his_is_pronoun() {
  function hers_is_pronoun (line 1778) | fn hers_is_pronoun() {
  function its_is_pronoun (line 1782) | fn its_is_pronoun() {
  function theirs_is_pronoun (line 1786) | fn theirs_is_pronoun() {
  function archaic_pronouns (line 1792) | fn archaic_pronouns() {
  function generic_pronouns (line 1801) | fn generic_pronouns() {
  function relative_and_interrogative_pronouns (line 1808) | fn relative_and_interrogative_pronouns() {
  function nonstandard_pronouns (line 1819) | fn nonstandard_pronouns() {
  function my_is_possessive_nominal (line 1829) | fn my_is_possessive_nominal() {
  function mine_is_not_possessive_nominal (line 1834) | fn mine_is_not_possessive_nominal() {
  function freds_is_possessive_nominal (line 1839) | fn freds_is_possessive_nominal() {
  function fred_is_not_possessive_nominal (line 1844) | fn fred_is_not_possessive_nominal() {
  function dogs_is_possessive_nominal (line 1849) | fn dogs_is_possessive_nominal() {
  function microsofts_is_possessive_nominal (line 1854) | fn microsofts_is_possessive_nominal() {
  function big_is_positive (line 1866) | fn big_is_positive() {
  function bigger_is_comparative (line 1871) | fn bigger_is_comparative() {
  function biggest_is_superlative (line 1876) | fn biggest_is_superlative() {
  function bigly_is_not_an_adjective_form_we_track (line 1882) | fn bigly_is_not_an_adjective_form_we_track() {
  function bigger_is_comparative_adjective (line 1891) | fn bigger_is_comparative_adjective() {
  function biggest_is_superlative_adjective (line 1896) | fn biggest_is_superlative_adjective() {
  function the_is_determiner (line 1902) | fn the_is_determiner() {
  function this_is_demonstrative_determiner (line 1906) | fn this_is_demonstrative_determiner() {
  function your_is_possessive_determiner (line 1910) | fn your_is_possessive_determiner() {
  function every_is_quantifier (line 1915) | fn every_is_quantifier() {
  function the_isnt_quantifier (line 1920) | fn the_isnt_quantifier() {
  function equipment_is_mass_noun (line 1925) | fn equipment_is_mass_noun() {
  function equipment_is_non_countable_noun (line 1930) | fn equipment_is_non_countable_noun() {
  function equipment_isnt_countable_noun (line 1935) | fn equipment_isnt_countable_noun() {
  function lemma_walk (line 1943) | fn lemma_walk() {
  function lemma_fix (line 1949) | fn lemma_fix() {
  function progressive_walking (line 1955) | fn progressive_walking() {
  function past_walked (line 1961) | fn past_walked() {
  function simple_past_ate (line 1967) | fn simple_past_ate() {
  function past_participle_eaten (line 1973) | fn past_participle_eaten() {
  function third_pers_sing_walks (line 1979) | fn third_pers_sing_walks() {

FILE: harper-core/src/dict_word_metadata_orthography.rs
  type Orthography (line 6) | pub enum Orthography {
  type OrthographyFlagsUnderlyingType (line 30) | type OrthographyFlagsUnderlyingType = u16;
  method default (line 51) | fn default() -> Self {
  method from_letters (line 58) | pub fn from_letters(letters: &[char]) -> Self {
  function looks_like_roman_numerals (line 148) | fn looks_like_roman_numerals(word: &[char]) -> bool {
  function is_really_roman_numerals (line 167) | fn is_really_roman_numerals(word: &[char]) -> bool {
  function check_roman_group (line 196) | fn check_roman_group<I: Iterator<Item = char>>(
  function orth_flags (line 239) | fn orth_flags(s: &str) -> OrthFlags {
  function test_lowercase_flags (line 245) | fn test_lowercase_flags() {
  function test_titlecase_flags (line 258) | fn test_titlecase_flags() {
  function test_allcaps_flags (line 274) | fn test_allcaps_flags() {
  function test_lower_camel_flags (line 287) | fn test_lower_camel_flags() {
  function test_upper_camel_flags (line 302) | fn test_upper_camel_flags() {
  function test_roman_numeral_flags (line 320) | fn test_roman_numeral_flags() {
  function test_single_roman_numeral_flags (line 331) | fn test_single_roman_numeral_flags() {
  function empty_string_is_not_roman_numeral (line 336) | fn empty_string_is_not_roman_numeral() {
  function dont_allow_mixed_case_roman_numerals (line 341) | fn dont_allow_mixed_case_roman_numerals() {
  function dont_allow_looks_like_but_isnt_roman_numeral (line 346) | fn dont_allow_looks_like_but_isnt_roman_numeral() {
  function australia_lexeme_is_titlecase_even_when_word_is_lowercase (line 352) | fn australia_lexeme_is_titlecase_even_when_word_is_lowercase() {
  function australia_lexeme_is_titlecase_even_when_word_is_all_caps (line 357) | fn australia_lexeme_is_titlecase_even_when_word_is_all_caps() {
  function australia_lexeme_is_titlecase_even_when_word_is_mixed_case (line 362) | fn australia_lexeme_is_titlecase_even_when_word_is_mixed_case() {
  function db_and_kw_symbols_are_lower_camel_case (line 367) | fn db_and_kw_symbols_are_lower_camel_case() {
  function am_is_lowercase_and_titlecase_and_all_caps (line 373) | fn am_is_lowercase_and_titlecase_and_all_caps() {
  function reading_is_both_lowercase_and_titlecase (line 382) | fn reading_is_both_lowercase_and_titlecase() {
  function ebay_and_esim_are_lower_camel (line 390) | fn ebay_and_esim_are_lower_camel() {

FILE: harper-core/src/document.rs
  type Document (line 19) | pub struct Document {
    method token_indices_intersecting (line 34) | pub fn token_indices_intersecting(&self, span: Span<char>) -> Vec<usiz...
    method fat_tokens_intersecting (line 44) | pub fn fat_tokens_intersecting(&self, span: Span<char>) -> Vec<FatToke...
    method new (line 55) | pub fn new(text: &str, parser: &impl Parser, dictionary: &impl Diction...
    method new_curated (line 63) | pub fn new_curated(text: &str, parser: &impl Parser) -> Self {
    method new_from_vec (line 71) | pub fn new_from_vec(
    method new_plain_english_curated_chars (line 86) | pub fn new_plain_english_curated_chars(source: &[char]) -> Self {
    method new_plain_english_curated (line 96) | pub fn new_plain_english_curated(text: &str) -> Self {
    method new_basic_tokenize (line 105) | pub(crate) fn new_basic_tokenize(text: &str, parser: &impl Parser) -> ...
    method new_plain_english (line 115) | pub fn new_plain_english(text: &str, dictionary: &impl Dictionary) -> ...
    method new_markdown_curated (line 121) | pub fn new_markdown_curated(text: &str, markdown_options: MarkdownOpti...
    method new_markdown_default_curated_chars (line 131) | pub fn new_markdown_default_curated_chars(chars: &[char]) -> Self {
    method new_markdown_default_curated (line 141) | pub fn new_markdown_default_curated(text: &str) -> Self {
    method new_markdown (line 147) | pub fn new_markdown(
    method new_markdown_default (line 157) | pub fn new_markdown_default(text: &str, dictionary: &impl Dictionary) ...
    method apply_fixups (line 161) | fn apply_fixups(&mut self) {
    method parse (line 180) | fn parse(&mut self, dictionary: &impl Dictionary) {
    method newlines_to_breaks (line 221) | fn newlines_to_breaks(&mut self) {
    method condense_indices (line 236) | fn condense_indices(&mut self, indices: &[usize], stretch_len: usize) {
    method get_token_at_char_index (line 273) | pub fn get_token_at_char_index(&self, char_index: usize) -> Option<&To...
    method get_token (line 289) | pub fn get_token(&self, index: usize) -> Option<&Token> {
    method get_token_offset (line 294) | pub fn get_token_offset(&self, base: usize, offset: isize) -> Option<&...
    method tokens (line 302) | pub fn tokens(&self) -> impl Iterator<Item = &Token> + '_ {
    method iter_nominal_phrases (line 306) | pub fn iter_nominal_phrases(&self) -> impl Iterator<Item = &[Token]> {
    method fat_tokens (line 341) | pub fn fat_tokens(&self) -> impl Iterator<Item = FatToken> + '_ {
    method get_next_word_from_offset (line 347) | pub fn get_next_word_from_offset(&self, base: usize, offset: isize) ->...
    method fat_string_tokens (line 359) | pub fn fat_string_tokens(&self) -> impl Iterator<Item = FatStringToken...
    method get_span_content (line 363) | pub fn get_span_content(&self, span: &Span<char>) -> &[char] {
    method get_span_content_str (line 367) | pub fn get_span_content_str(&self, span: &Span<char>) -> String {
    method get_full_string (line 371) | pub fn get_full_string(&self) -> String {
    method get_full_content (line 375) | pub fn get_full_content(&self) -> &[char] {
    method get_source (line 379) | pub fn get_source(&self) -> &[char] {
    method get_tokens (line 383) | pub fn get_tokens(&self) -> &[Token] {
    method match_quotes (line 392) | fn match_quotes(&mut self) {
    method condense_number_suffixes (line 454) | fn condense_number_suffixes(&mut self) {
    method condense_spaces (line 481) | fn condense_spaces(&mut self) {
    method uncached_dotted_truncation_expr (line 527) | fn uncached_dotted_truncation_expr() -> Lrc<FirstMatchOf> {
    method condense_expr (line 541) | fn condense_expr<F>(&mut self, expr: &impl Expr, edit: F)
    method condense_dotted_truncations (line 558) | fn condense_dotted_truncations(&mut self) {
    method condense_newlines (line 564) | fn condense_newlines(&mut self) {
    method condense_dotted_initialisms (line 602) | fn condense_dotted_initialisms(&mut self) {
    method condense_filename_extensions (line 649) | fn condense_filename_extensions(&mut self) {
    method condense_common_top_level_domains (line 711) | fn condense_common_top_level_domains(&mut self) {
    method condense_tldr (line 762) | fn condense_tldr(&mut self) {
    method condense_delimited_pairs (line 821) | fn condense_delimited_pairs<F>(&mut self, is_delimiter: F, valid_pairs...
    method condense_ampersand_pairs (line 877) | fn condense_ampersand_pairs(&mut self) {
    method condense_slash_pairs (line 895) | fn condense_slash_pairs(&mut self) {
    method uncached_ellipsis_pattern (line 915) | fn uncached_ellipsis_pattern() -> Lrc<Repeating> {
    method condense_ellipsis (line 924) | fn condense_ellipsis(&mut self) {
  method default (line 25) | fn default() -> Self {
  method first_sentence_word (line 985) | fn first_sentence_word(&self) -> Option<&Token> {
  method first_non_whitespace (line 989) | fn first_non_whitespace(&self) -> Option<&Token> {
  method span (line 993) | fn span(&self) -> Option<Span<char>> {
  method iter_linking_verb_indices (line 997) | fn iter_linking_verb_indices(&self) -> impl Iterator<Item = usize> + '_ {
  method iter_linking_verbs (line 1001) | fn iter_linking_verbs(&self) -> impl Iterator<Item = &Token> + '_ {
  method iter_chunks (line 1005) | fn iter_chunks(&self) -> impl Iterator<Item = &'_ [Token]> + '_ {
  method iter_paragraphs (line 1009) | fn iter_paragraphs(&self) -> impl Iterator<Item = &'_ [Token]> + '_ {
  method iter_headings (line 1013) | fn iter_headings(&self) -> impl Iterator<Item = &'_ [Token]> + '_ {
  method iter_sentences (line 1017) | fn iter_sentences(&self) -> impl Iterator<Item = &'_ [Token]> + '_ {
  method iter_sentences_mut (line 1021) | fn iter_sentences_mut(&mut self) -> impl Iterator<Item = &'_ mut [Token]...
  method fmt (line 1027) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  function assert_condensed_contractions (line 1044) | fn assert_condensed_contractions(text: &str, final_tok_count: usize) {
  function simple_contraction (line 1055) | fn simple_contraction() {
  function simple_contraction2 (line 1060) | fn simple_contraction2() {
  function simple_contraction3 (line 1065) | fn simple_contraction3() {
  function simple_contraction4 (line 1070) | fn simple_contraction4() {
  function medium_contraction (line 1075) | fn medium_contraction() {
  function medium_contraction2 (line 1080) | fn medium_contraction2() {
  function selects_token_at_char_index (line 1085) | fn selects_token_at_char_index() {
  function assert_token_count (line 1095) | fn assert_token_count(source: &str, count: usize) {
  function condenses_number_suffixes (line 1103) | fn condenses_number_suffixes() {
  function condenses_ie (line 1114) | fn condenses_ie() {
  function condenses_eg (line 1121) | fn condenses_eg() {
  function condenses_nsa (line 1127) | fn condenses_nsa() {
  function parses_ellipsis (line 1132) | fn parses_ellipsis() {
  function parses_long_ellipsis (line 1137) | fn parses_long_ellipsis() {
  function parses_short_ellipsis (line 1142) | fn parses_short_ellipsis() {
  function selects_token_at_offset (line 1147) | fn selects_token_at_offset() {
  function cant_select_token_before_start (line 1156) | fn cant_select_token_before_start() {
  function select_next_word_pos_offset (line 1165) | fn select_next_word_pos_offset() {
  function select_next_word_neg_offset (line 1174) | fn select_next_word_neg_offset() {
  function cant_select_next_word_not_from_whitespace (line 1183) | fn cant_select_next_word_not_from_whitespace() {
  function cant_select_next_word_before_start (line 1192) | fn cant_select_next_word_before_start() {
  function cant_select_next_word_with_punctuation_instead_of_whitespace (line 1201) | fn cant_select_next_word_with_punctuation_instead_of_whitespace() {
  function cant_select_next_word_with_punctuation_after_whitespace (line 1210) | fn cant_select_next_word_with_punctuation_after_whitespace() {
  function condenses_filename_extensions (line 1219) | fn condenses_filename_extensions() {
  function condense_filename_extension_ok_at_start_and_end (line 1227) | fn condense_filename_extension_ok_at_start_and_end() {
  function doesnt_condense_filename_extensions_with_mixed_case (line 1235) | fn doesnt_condense_filename_extensions_with_mixed_case() {
  function doesnt_condense_filename_extensions_with_non_letters (line 1244) | fn doesnt_condense_filename_extensions_with_non_letters() {
  function doesnt_condense_filename_extensions_longer_than_three (line 1253) | fn doesnt_condense_filename_extensions_longer_than_three() {
  function condense_filename_extension_in_parens (line 1262) | fn condense_filename_extension_in_parens() {
  function condense_tldr_uppercase (line 1273) | fn condense_tldr_uppercase() {
  function condense_tldr_lowercase (line 1281) | fn condense_tldr_lowercase() {
  function condense_tldr_mixed_case_1 (line 1288) | fn condense_tldr_mixed_case_1() {
  function condense_tldr_mixed_case_2 (line 1295) | fn condense_tldr_mixed_case_2() {
  function condense_tldr_pural (line 1302) | fn condense_tldr_pural() {
  function condense_common_top_level_domains (line 1323) | fn condense_common_top_level_domains() {
  function condense_common_top_level_domains_in_parens (line 1332) | fn condense_common_top_level_domains_in_parens() {
  function doesnt_condense_unknown_top_level_domains (line 1341) | fn doesnt_condense_unknown_top_level_domains() {
  function condense_r_and_d_caps (line 1349) | fn condense_r_and_d_caps() {
  function condense_r_and_d_mixed_case (line 1356) | fn condense_r_and_d_mixed_case() {
  function condense_r_and_d_lowercase (line 1363) | fn condense_r_and_d_lowercase() {
  function dont_condense_r_and_d_with_spaces (line 1370) | fn dont_condense_r_and_d_with_spaces() {
  function condense_q_and_a (line 1381) | fn condense_q_and_a() {
  function dont_allow_mixed_r_and_d_with_q_and_a (line 1390) | fn dont_allow_mixed_r_and_d_with_q_and_a() {
  function condense_io (line 1397) | fn condense_io() {
  function finds_unmatched_quotes_in_document (line 1404) | fn finds_unmatched_quotes_in_document() {
  function issue_1901 (line 1429) | fn issue_1901() {

FILE: harper-core/src/edit_distance.rs
  function edit_distance_min_alloc (line 6) | pub fn edit_distance_min_alloc(
  function edit_distance (line 41) | pub fn edit_distance(source: &[char], target: &[char]) -> u8 {
  function assert_edit_dist (line 49) | fn assert_edit_dist(source: &str, target: &str, expected: u8) {
  function simple_edit_distance_1 (line 58) | fn simple_edit_distance_1() {
  function simple_edit_distance_2 (line 63) | fn simple_edit_distance_2() {
  function one_edit_distance (line 68) | fn one_edit_distance() {
  function zero_edit_distance (line 87) | fn zero_edit_distance() {

FILE: harper-core/src/expr/all.rs
  type All (line 9) | pub struct All {
    method new (line 14) | pub fn new(children: Vec<Box<dyn Expr>>) -> Self {
    method add (line 18) | pub fn add(&mut self, e: impl Expr + 'static) {
  method run (line 24) | fn run(&self, cursor: usize, tokens: &[Token], source: &[char]) -> Optio...

FILE: harper-core/src/expr/anchor_end.rs
  type AnchorEnd (line 9) | pub struct AnchorEnd;
  method step (line 12) | fn step(&self, tokens: &[Token], cursor: usize, _source: &[char]) -> Opt...
  function matches_period (line 37) | fn matches_period() {
  function does_not_match_empty (line 45) | fn does_not_match_empty() {

FILE: harper-core/src/expr/anchor_start.rs
  type AnchorStart (line 7) | pub struct AnchorStart;
  method step (line 10) | fn step(&self, tokens: &[Token], cursor: usize, _source: &[char]) -> Opt...
  function matches_first_word (line 27) | fn matches_first_word() {
  function does_not_match_empty (line 35) | fn does_not_match_empty() {

FILE: harper-core/src/expr/duration_expr.rs
  type DurationExpr (line 7) | pub struct DurationExpr;
  method run (line 10) | fn run(&self, cursor: usize, tokens: &[Token], source: &[char]) -> Optio...
  function detect_10_days (line 40) | fn detect_10_days() {
  function detect_ten_days (line 47) | fn detect_ten_days() {

FILE: harper-core/src/expr/expr_map.rs
  type ExprMap (line 18) | pub struct ExprMap<T>
  type Row (line 25) | struct Row<T>
  method default (line 37) | fn default() -> Self {
  function insert (line 48) | pub fn insert(&mut self, expr: impl Expr + 'static, value: T) {
  function lookup (line 56) | pub fn lookup(&self, cursor: usize, tokens: &[Token], source: &[char]) -...
  method run (line 68) | fn run(&self, cursor: usize, tokens: &[Token], source: &[char]) -> Optio...

FILE: harper-core/src/expr/filter.rs
  type Filter (line 29) | pub struct Filter {
    method new (line 34) | pub fn new(steps: Vec<Box<dyn Expr>>) -> Self {
  method run (line 40) | fn run(&self, cursor: usize, tokens: &[Token], source: &[char]) -> Optio...

FILE: harper-core/src/expr/first_match_of.rs
  type FirstMatchOf (line 9) | pub struct FirstMatchOf {
    method new (line 14) | pub fn new(exprs: Vec<Box<dyn Expr>>) -> Self {
    method add (line 18) | pub fn add(&mut self, expr: impl Expr + 'static) {
    method add_boxed (line 22) | pub fn add_boxed(&mut self, expr: Box<dyn Expr>) {
  method run (line 28) | fn run(&self, cursor: usize, tokens: &[Token], source: &[char]) -> Optio...

FILE: harper-core/src/expr/fixed_phrase.rs
  type FixedPhrase (line 20) | pub struct FixedPhrase {
    method from_phrase (line 27) | pub fn from_phrase(text: &str) -> Self {
    method from_document (line 34) | pub fn from_document(doc: &Document) -> Self {
  method run (line 62) | fn run(&self, cursor: usize, tokens: &[Token], source: &[char]) -> Optio...
  function test_not_case_sensitive (line 74) | fn test_not_case_sensitive() {

FILE: harper-core/src/expr/longest_match_of.rs
  type LongestMatchOf (line 5) | pub struct LongestMatchOf {
    method new (line 10) | pub fn new(exprs: Vec<Box<dyn Expr>>) -> Self {
    method add (line 14) | pub fn add(&mut self, expr: impl Expr + 'static) {
  method run (line 20) | fn run(&self, cursor: usize, tokens: &[Token], source: &[char]) -> Optio...

FILE: harper-core/src/expr/mergeable_words.rs
  type PredicateFn (line 7) | type PredicateFn =
  type MergeableWords (line 14) | pub struct MergeableWords {
    method new (line 21) | pub fn new(
    method get_merged_word (line 36) | pub fn get_merged_word(
  method run (line 64) | fn run(&self, cursor: usize, tokens: &[Token], source: &[char]) -> Optio...
  function predicate (line 87) | fn predicate(
  function merges_open_compound_not_in_dict (line 95) | fn merges_open_compound_not_in_dict() {
  function does_not_merge_open_compound_in_dict (line 107) | fn does_not_merge_open_compound_in_dict() {
  function does_not_merge_invalid_compound (line 119) | fn does_not_merge_invalid_compound() {
  function merges_open_compound (line 131) | fn merges_open_compound() {
  function merges_hyphenated_compound (line 143) | fn merges_hyphenated_compound() {

FILE: harper-core/src/expr/mod.rs
  type Expr (line 66) | pub trait Expr: LSend {
    method run (line 67) | fn run(&self, cursor: usize, tokens: &[Token], source: &[char]) -> Opt...
    method run (line 74) | fn run(&self, cursor: usize, tokens: &[Token], source: &[char]) -> Opt...
    method run (line 89) | fn run(&self, cursor: usize, tokens: &[Token], source: &[char]) -> Opt...
    method run (line 95) | fn run(&self, cursor: usize, tokens: &[Token], source: &[char]) -> Opt...
    method run (line 105) | fn run(&self, cursor: usize, tokens: &[Token], source: &[char]) -> Opt...
  function add (line 110) | fn add(u: usize, i: isize) -> Option<usize> {
  type ExprExt (line 118) | pub trait ExprExt {
    method iter_matches (line 121) | fn iter_matches<'a>(
    method iter_matches_in_doc (line 127) | fn iter_matches_in_doc<'a>(
    method iter_matches (line 137) | fn iter_matches<'a>(
    method iter_matches_in_doc (line 155) | fn iter_matches_in_doc<'a>(
  type OwnedExprExt (line 163) | pub trait OwnedExprExt {
    method or (line 164) | fn or(self, other: impl Expr + 'static) -> FirstMatchOf;
    method and (line 165) | fn and(self, other: impl Expr + 'static) -> All;
    method and_not (line 166) | fn and_not(self, other: impl Expr + 'static) -> All;
    method or_longest (line 167) | fn or_longest(self, other: impl Expr + 'static) -> LongestMatchOf;
    method or (line 175) | fn or(self, other: impl Expr + 'static) -> FirstMatchOf {
    method and (line 180) | fn and(self, other: impl Expr + 'static) -> All {
    method and_not (line 185) | fn and_not(self, other: impl Expr + 'static) -> All {
    method or_longest (line 192) | fn or_longest(self, other: impl Expr + 'static) -> LongestMatchOf {

FILE: harper-core/src/expr/optional.rs
  type Optional (line 8) | pub struct Optional {
    method new (line 13) | pub fn new(inner: impl Expr + 'static) -> Self {
  method run (line 21) | fn run(&self, cursor: usize, tokens: &[Token], source: &[char]) -> Optio...

FILE: harper-core/src/expr/reflexive_pronoun.rs
  constant BAD_REFLEXIVE_PRONOUNS (line 9) | const BAD_REFLEXIVE_PRONOUNS: &[&str] = &[
  type ReflexivePronoun (line 21) | pub struct ReflexivePronoun {
    method standard (line 36) | pub fn standard() -> Self {
    method with_common_errors (line 46) | pub fn with_common_errors() -> Self {
  method default (line 26) | fn default() -> Self {
  method run (line 54) | fn run(&self, cursor: usize, tokens: &[Token], source: &[char]) -> Optio...
  constant GOOD_REFLEXIVE_PRONOUNS (line 73) | const GOOD_REFLEXIVE_PRONOUNS: &[&str] = &[
  function test_pronoun (line 87) | fn test_pronoun(word: &str) {
  function test_good_reflexive_pronouns (line 116) | fn test_good_reflexive_pronouns() {
  function test_bad_reflexive_pronouns (line 123) | fn test_bad_reflexive_pronouns() {
  function test_non_pronouns (line 131) | fn test_non_pronouns() {
  function ensure_standard_ctor_includes_myself (line 139) | fn ensure_standard_ctor_includes_myself() {
  function ensure_default_ctor_includes_myself (line 148) | fn ensure_default_ctor_includes_myself() {
  function ensure_with_common_errors_includes_hisself (line 158) | fn ensure_with_common_errors_includes_hisself() {
  function ensure_standard_ctor_excludes_hisself (line 166) | fn ensure_standard_ctor_excludes_hisself() {
  function ensure_default_ctor_excludes_theirself (line 174) | fn ensure_default_ctor_excludes_theirself() {

FILE: harper-core/src/expr/repeating.rs
  type Repeating (line 7) | pub struct Repeating {
    method new (line 13) | pub fn new(expr: Box<dyn Expr>, required_repetitions: usize) -> Self {
  method run (line 22) | fn run(&self, mut cursor: usize, tokens: &[Token], source: &[char]) -> O...
  function matches_anything (line 62) | fn matches_anything() {
  function does_not_match_short (line 75) | fn does_not_match_short() {

FILE: harper-core/src/expr/sequence_expr.rs
  type SequenceExpr (line 12) | pub struct SequenceExpr {
    method with (line 84) | pub fn with(expr: impl Expr + 'static) -> Self {
    method anything (line 91) | pub fn anything() -> Self {
    method any_capitalization_of (line 98) | pub fn any_capitalization_of(word: &'static str) -> Self {
    method aco (line 103) | pub fn aco(word: &'static str) -> Self {
    method word_set (line 108) | pub fn word_set(words: &'static [&'static str]) -> Self {
    method any_word (line 113) | pub fn any_word() -> Self {
    method optional (line 120) | pub fn optional(expr: impl Expr + 'static) -> Self {
    method fixed_phrase (line 125) | pub fn fixed_phrase(phrase: &'static str) -> Self {
    method any_of (line 132) | pub fn any_of(exprs: Vec<Box<dyn Expr>>) -> Self {
    method longest_of (line 137) | pub fn longest_of(exprs: Vec<Box<dyn Expr>>) -> Self {
    method whitespace (line 141) | pub fn whitespace() -> Self {
    method unless (line 146) | pub fn unless(condition: impl Expr + 'static) -> Self {
    method then (line 153) | pub fn then(mut self, expr: impl Expr + 'static) -> Self {
    method then_boxed (line 159) | pub fn then_boxed(mut self, expr: Box<dyn Expr>) -> Self {
    method then_optional (line 165) | pub fn then_optional(mut self, expr: impl Expr + 'static) -> Self {
    method then_any_of (line 175) | pub fn then_any_of(mut self, exprs: Vec<Box<dyn Expr>>) -> Self {
    method then_longest_of (line 184) | pub fn then_longest_of(mut self, exprs: Vec<Box<dyn Expr>>) -> Self {
    method then_seq (line 191) | pub fn then_seq(mut self, mut other: Self) -> Self {
    method then_word_set (line 197) | pub fn then_word_set(self, words: &'static [&'static str]) -> Self {
    method t_set (line 202) | pub fn t_set(self, words: &'static [&'static str]) -> Self {
    method then_whitespace (line 207) | pub fn then_whitespace(self) -> Self {
    method t_ws (line 212) | pub fn t_ws(self) -> Self {
    method then_whitespace_or_hyphen (line 217) | pub fn then_whitespace_or_hyphen(self) -> Self {
    method t_ws_h (line 222) | pub fn t_ws_h(self) -> Self {
    method then_zero_or_more (line 227) | pub fn then_zero_or_more(self, expr: impl Expr + 'static) -> Self {
    method then_one_or_more (line 232) | pub fn then_one_or_more(self, expr: impl Expr + 'static) -> Self {
    method then_zero_or_more_spaced (line 237) | pub fn then_zero_or_more_spaced(self, expr: impl Expr + 'static) -> Se...
    method then_unless (line 251) | pub fn then_unless(self, condition: impl Expr + 'static) -> Self {
    method then_anything (line 260) | pub fn then_anything(self) -> Self {
    method t_any (line 267) | pub fn t_any(self) -> Self {
    method then_any_word (line 274) | pub fn then_any_word(self) -> Self {
    method then_any_capitalization_of (line 279) | pub fn then_any_capitalization_of(self, word: &'static str) -> Self {
    method t_aco (line 284) | pub fn t_aco(self, word: &'static str) -> Self {
    method then_exact_word (line 289) | pub fn then_exact_word(self, word: &'static str) -> Self {
    method then_fixed_phrase (line 294) | pub fn then_fixed_phrase(self, phrase: &'static str) -> Self {
    method then_word_except (line 299) | pub fn then_word_except(self, words: &'static [&'static str]) -> Self {
    method then_kind (line 313) | pub fn then_kind(self, kind: TokenKind) -> Self {
    method then_kind_where (line 318) | pub fn then_kind_where<F>(mut self, predicate: F) -> Self
    method then_kind_except (line 330) | pub fn then_kind_except<F>(self, pred_is: F, ex: &'static [&'static st...
    method then_kind_both (line 346) | pub fn then_kind_both<F1, F2>(self, pred_is_1: F1, pred_is_2: F2) -> Self
    method then_kind_either (line 356) | pub fn then_kind_either<F1, F2>(self, pred_is_1: F1, pred_is_2: F2) ->...
    method then_kind_neither (line 366) | pub fn then_kind_neither<F1, F2>(self, pred_isnt_1: F1, pred_isnt_2: F...
    method then_kind_is_but_is_not (line 376) | pub fn then_kind_is_but_is_not<F1, F2>(self, pred_is: F1, pred_not: F2...
    method then_kind_is_but_is_not_except (line 386) | pub fn then_kind_is_but_is_not_except<F1, F2>(
    method then_kind_is_but_isnt_any_of (line 407) | pub fn then_kind_is_but_isnt_any_of<F1, F2>(
    method then_kind_is_but_isnt_any_of_except (line 422) | pub fn then_kind_is_but_isnt_any_of_except<F1, F2>(
    method then_kind_both_but_not (line 446) | pub fn then_kind_both_but_not<F1, F2, F3>(
    method then_kind_any (line 461) | pub fn then_kind_any<F>(self, preds_is: &'static [F]) -> Self
    method then_kind_none_of (line 470) | pub fn then_kind_none_of<F>(self, preds_isnt: &'static [F]) -> Self
    method then_kind_any_except (line 479) | pub fn then_kind_any_except<F>(
    method then_kind_any_or_words (line 497) | pub fn then_kind_any_or_words<F>(
    method then_kind_any_but_not_except (line 515) | pub fn then_kind_any_but_not_except<F1, F2>(
    method then_indefinite_article (line 604) | pub fn then_indefinite_article(self) -> Self {
    method from (line 644) | fn from(step: S) -> Self {
  method run (line 55) | fn run(&self, mut cursor: usize, tokens: &[Token], source: &[char]) -> O...
  function test_kind_both (line 660) | fn test_kind_both() {
  function test_adjective_or_determiner (line 669) | fn test_adjective_or_determiner() {
  function test_noun_but_not_adjective (line 678) | fn test_noun_but_not_adjective() {

FILE: harper-core/src/expr/similar_to_phrase.rs
  type SimilarToPhrase (line 6) | pub struct SimilarToPhrase {
    method from_phrase (line 18) | pub fn from_phrase(text: &str, max_edit_dist: u8) -> Self {
    method from_doc (line 30) | pub fn from_doc(document: &Document, max_edit_dist: u8) -> Self {
  method run (line 61) | fn run(&self, cursor: usize, tokens: &[Token], source: &[char]) -> Optio...

FILE: harper-core/src/expr/space_or_hyphen.rs
  type SpaceOrHyphen (line 9) | pub struct SpaceOrHyphen;
  method run (line 12) | fn run(&self, cursor: usize, tokens: &[Token], source: &[char]) -> Optio...

FILE: harper-core/src/expr/spelled_number_expr.rs
  type SpelledNumberExpr (line 9) | pub struct SpelledNumberExpr;
  method run (line 12) | fn run(&self, cursor: usize, tokens: &[Token], source: &[char]) -> Optio...
  function matches_single_digit (line 76) | fn matches_single_digit() {
  function matches_teens (line 83) | fn matches_teens() {
  function matches_tens (line 90) | fn matches_tens() {
  function matches_compound_numbers (line 97) | fn matches_compound_numbers() {
  function deep_thought (line 117) | fn deep_thought() {
  function jacksons (line 132) | fn jacksons() {
  function orwell (line 144) | fn orwell() {
  function get_smart (line 154) | fn get_smart() {
  function hyphens_or_spaces (line 166) | fn hyphens_or_spaces() {
  function waiting_since (line 190) | fn waiting_since() {

FILE: harper-core/src/expr/step.rs
  type Step (line 8) | pub trait Step: LSend {
    method step (line 9) | fn step(&self, tokens: &[Token], cursor: usize, source: &[char]) -> Op...
    method step (line 16) | fn step(&self, tokens: &[Token], cursor: usize, source: &[char]) -> Op...

FILE: harper-core/src/expr/time_unit_expr.rs
  type TimeUnitExpr (line 15) | pub struct TimeUnitExpr;
  method run (line 18) | fn run(&self, cursor: usize, tokens: &[Token], source: &[char]) -> Optio...

FILE: harper-core/src/expr/unless_step.rs
  type UnlessStep (line 7) | pub struct UnlessStep<E: Expr, S: Step> {
  function new (line 17) | pub fn new(condition: E, step: S) -> Self {
  method step (line 23) | fn step(&self, tokens: &[Token], cursor: usize, source: &[char]) -> Opti...

FILE: harper-core/src/expr/word_expr_group.rs
  type WordExprGroup (line 12) | pub struct WordExprGroup<E>
  function add (line 20) | pub fn add(&mut self, word: &str, expr: impl Expr + 'static) {
  function add_word (line 33) | pub fn add_word(&mut self, word: &'static str) {
  method run (line 42) | fn run(&self, cursor: usize, tokens: &[Token], source: &[char]) -> Optio...

FILE: harper-core/src/fat_token.rs
  type FatToken (line 8) | pub struct FatToken {
    method from (line 14) | fn from(value: FatStringToken) -> Self {
  type FatStringToken (line 24) | pub struct FatStringToken {
    method from (line 30) | fn from(value: FatToken) -> Self {

FILE: harper-core/src/ignored_lints/lint_context.rs
  type LintContext (line 13) | pub struct LintContext {
    method from_lint (line 22) | pub fn from_lint(lint: &Lint, document: &Document) -> Self {
    method default_hash (line 57) | pub fn default_hash(&self) -> u64 {

FILE: harper-core/src/ignored_lints/mod.rs
  type IgnoredLints (line 14) | pub struct IgnoredLints {
    method new (line 19) | pub fn new() -> Self {
    method append (line 24) | pub fn append(&mut self, other: Self) {
    method ignore_lint (line 29) | pub fn ignore_lint(&mut self, lint: &Lint, document: &Document) {
    method ignore_hash (line 37) | pub fn ignore_hash(&mut self, hash: u64) {
    method is_ignored (line 41) | pub fn is_ignored(&self, lint: &Lint, document: &Document) -> bool {
    method remove_ignored (line 49) | pub fn remove_ignored(&self, lints: &mut Vec<Lint>, document: &Documen...
  function can_ignore_all (line 71) | fn can_ignore_all(text: String) -> bool {
  function can_ignore_first (line 88) | fn can_ignore_first(text: String) -> TestResult {
  function assert_ignore_lint_reduction (line 107) | fn assert_ignore_lint_reduction(source: &str, nth_lint: usize) {
  function an_a (line 129) | fn an_a() {
  function spelling (line 137) | fn spelling() {

FILE: harper-core/src/indefinite_article.rs
  type InitialSound (line 10) | pub enum InitialSound {
  function starts_with_vowel (line 21) | pub fn starts_with_vowel(word: &[char], dialect: Dialect) -> Option<Init...
  function to_lower_word (line 166) | fn to_lower_word(word: &[char]) -> Cow<'_, [char]> {
  function is_likely_acronym (line 178) | fn is_likely_acronym(word: &[char]) -> bool {

FILE: harper-core/src/irregular_nouns.rs
  type Noun (line 4) | type Noun = (String, String);
  type IrregularNouns (line 7) | pub struct IrregularNouns {
    method new (line 22) | pub fn new() -> Self {
    method from_json_file (line 26) | pub fn from_json_file(json: &str) -> Result<Self, serde_json::Error> {
    method curated (line 50) | pub fn curated() -> Arc<Self> {
    method get_plural_for_singular (line 54) | pub fn get_plural_for_singular(&self, singular: &str) -> Option<&str> {
    method get_singular_for_plural (line 61) | pub fn get_singular_for_plural(&self, plural: &str) -> Option<&str> {
  function uncached_inner_new (line 13) | fn uncached_inner_new() -> Arc<IrregularNouns> {
  method default (line 70) | fn default() -> Self {
  function can_find_irregular_plural_for_singular_lowercase (line 80) | fn can_find_irregular_plural_for_singular_lowercase() {
  function can_find_irregular_plural_for_singular_uppercase (line 88) | fn can_find_irregular_plural_for_singular_uppercase() {
  function can_find_singular_for_irregular_plural (line 96) | fn can_find_singular_for_irregular_plural() {
  function cant_find_regular_plural (line 104) | fn cant_find_regular_plural() {
  function cant_find_non_noun (line 112) | fn cant_find_non_noun() {

FILE: harper-core/src/irregular_verbs.rs
  type Verb (line 4) | type Verb = (String, String, String);
  type IrregularVerbs (line 7) | pub struct IrregularVerbs {
    method new (line 22) | pub fn new() -> Self {
    method from_json_file (line 26) | pub fn from_json_file(json: &str) -> Result<Self, serde_json::Error> {
    method curated (line 56) | pub fn curated() -> Arc<Self> {
    method get_past_participle_for_preterite (line 60) | pub fn get_past_participle_for_preterite(&self, preterite: &str) -> Op...
    method get_lemma_for_preterite (line 67) | pub fn get_lemma_for_preterite(&self, preterite: &str) -> Option<&str> {
    method get_pasts_for_lemma (line 74) | pub fn get_pasts_for_lemma(&self, lemma: &str) -> Option<(&str, &str)> {
  function uncached_inner_new (line 13) | fn uncached_inner_new() -> Arc<IrregularVerbs> {
  method default (line 83) | fn default() -> Self {
  function can_find_irregular_past_participle_for_preterite_lowercase (line 93) | fn can_find_irregular_past_participle_for_preterite_lowercase() {
  function can_find_irregular_past_participle_for_preterite_uppercase (line 101) | fn can_find_irregular_past_participle_for_preterite_uppercase() {
  function can_find_irregular_past_participle_same_as_past_tense (line 109) | fn can_find_irregular_past_participle_same_as_past_tense() {
  function cant_find_regular_past_participle (line 117) | fn cant_find_regular_past_participle() {
  function cant_find_non_verb (line 125) | fn cant_find_non_verb() {

FILE: harper-core/src/language_detection.rs
  function is_doc_likely_english (line 8) | pub fn is_doc_likely_english(doc: &Document, dict: &impl Dictionary) -> ...
  function is_likely_english (line 13) | pub fn is_likely_english(toks: &[Token], source: &[char], dict: &impl Di...
  function assert_not_english (line 60) | fn assert_not_english(source: &'static str) {
  function assert_english (line 68) | fn assert_english(source: &'static str) {
  function detects_spanish (line 77) | fn detects_spanish() {
  function detects_french (line 82) | fn detects_french() {
  function detects_shebang (line 89) | fn detects_shebang() {
  function detects_short_english (line 95) | fn detects_short_english() {
  function detects_english (line 100) | fn detects_english() {
  function detects_expressive_english (line 105) | fn detects_expressive_english() {
  function detects_python_fib (line 111) | fn detects_python_fib() {
  function mixed_french_english_park (line 127) | fn mixed_french_english_park() {
  function mixed_french_english_drunk (line 132) | fn mixed_french_english_drunk() {
  function mixed_french_english_dress (line 137) | fn mixed_french_english_dress() {
  function english_motto (line 144) | fn english_motto() {

FILE: harper-core/src/lexing/email_address.rs
  constant MAX_EMAIL_LEN (line 8) | pub(crate) const MAX_EMAIL_LEN: usize = 254;
  function lex_email_address (line 10) | pub fn lex_email_address(source: &[char]) -> Option<FoundToken> {
  function validate_local_part (line 49) | fn validate_local_part(mut local_part: &[char]) -> bool {
  function valid_unquoted_character (line 101) | fn valid_unquoted_character(c: char) -> bool {
  function example_local_parts (line 133) | fn example_local_parts() -> impl Iterator<Item = Vec<char>> {
  function example_local_parts_pass_validation (line 158) | fn example_local_parts_pass_validation() {
  function test_many_example_email_addresses (line 166) | fn test_many_example_email_addresses() {
  function does_not_allow_empty_domain (line 182) | fn does_not_allow_empty_domain() {
  function survives_random_chars (line 196) | fn survives_random_chars() {

FILE: harper-core/src/lexing/hostname.rs
  function lex_hostname_token (line 6) | pub fn lex_hostname_token(source: &[char]) -> Option<FoundToken> {
  function lex_hostname (line 33) | pub fn lex_hostname(source: &[char]) -> Option<usize> {
  constant COMMON_TLDS (line 61) | const COMMON_TLDS: &[&[char]] = &[
  function ends_with_common_tld (line 79) | fn ends_with_common_tld(input: &[char]) -> bool {
  function example_domain_parts (line 93) | pub fn example_domain_parts() -> impl Iterator<Item = Vec<char>> {
  function can_parse_example_hostnames (line 115) | fn can_parse_example_hostnames() {
  function hyphen_cannot_open_hostname (line 123) | fn hyphen_cannot_open_hostname() {

FILE: harper-core/src/lexing/mod.rs
  type FoundToken (line 15) | pub struct FoundToken {
  function lex_with (line 26) | pub fn lex_with(source: &[char], lex_fn: fn(&[char]) -> FoundToken) -> V...
  function lex_weir_token (line 45) | pub fn lex_weir_token(source: &[char]) -> FoundToken {
  function lex_english_token (line 65) | pub fn lex_english_token(source: &[char]) -> FoundToken {
  function lex_word (line 86) | fn lex_word(source: &[char]) -> Option<FoundToken> {
  function lex_number (line 108) | fn lex_number(source: &[char]) -> Option<FoundToken> {
  function lex_regexish (line 151) | fn lex_regexish(src: &[char]) -> Option<FoundToken> {
  function lex_hex_number (line 185) | fn lex_hex_number(source: &[char]) -> Option<FoundToken> {
  function lex_long_decade (line 226) | fn lex_long_decade(source: &[char]) -> Option<FoundToken> {
  function lex_plural_digit (line 253) | fn lex_plural_digit(src: &[char]) -> Option<FoundToken> {
  function lex_newlines (line 280) | fn lex_newlines(source: &[char]) -> Option<FoundToken> {
  function lex_tabs (line 293) | fn lex_tabs(source: &[char]) -> Option<FoundToken> {
  function lex_spaces (line 306) | fn lex_spaces(source: &[char]) -> Option<FoundToken> {
  function lex_punctuation (line 319) | fn lex_punctuation(source: &[char]) -> Option<FoundToken> {
  function lex_quote (line 333) | fn lex_quote(source: &[char]) -> Option<FoundToken> {
  function lex_catch (line 347) | fn lex_catch() -> FoundToken {
  function lexes_0 (line 369) | fn lexes_0() {
  function lexes_0_point_0 (line 381) | fn lexes_0_point_0() {
  function lexes_00 (line 393) | fn lexes_00() {
  function lexes_negative_1 (line 405) | fn lexes_negative_1() {
  function lexes_positive_1 (line 417) | fn lexes_positive_1() {
  function lexes_pi (line 429) | fn lexes_pi() {
  function lexes_speed_of_light (line 441) | fn lexes_speed_of_light() {
  function doesnt_lex_cjk_numeral (line 453) | fn doesnt_lex_cjk_numeral() {
  function doesnt_lex_thai_digit (line 459) | fn doesnt_lex_thai_digit() {
  function lexes_cjk_as_unlintable (line 465) | fn lexes_cjk_as_unlintable() {
  function lexes_youtube_as_hostname (line 471) | fn lexes_youtube_as_hostname() {
  function doesnt_lex_regex_mini_range (line 483) | fn doesnt_lex_regex_mini_range() {
  function lexes_regex_one_letter (line 495) | fn lexes_regex_one_letter() {
  function lexes_regex_two_letters (line 507) | fn lexes_regex_two_letters() {
  function lexes_regex_digits (line 519) | fn lexes_regex_digits() {
  function lexes_regex_two_alphanumeric (line 531) | fn lexes_regex_two_alphanumeric() {
  function lexes_regex_one_range (line 543) | fn lexes_regex_one_range() {
  function lexes_regex_letter_plus_range (line 555) | fn lexes_regex_letter_plus_range() {
  function lexes_regex_range_plus_letter (line 567) | fn lexes_regex_range_plus_letter() {
  function lexes_regex_two_ranges (line 579) | fn lexes_regex_two_ranges() {
  function doesnt_lex_regex_broken_two_ranges (line 591) | fn doesnt_lex_regex_broken_two_ranges() {
  function doesnt_lex_regex_hyphen_at_start (line 604) | fn doesnt_lex_regex_hyphen_at_start() {
  function doesnt_lex_regex_hyphen_at_end (line 616) | fn doesnt_lex_regex_hyphen_at_end() {
  function lexes_good_hex_numeric (line 628) | fn lexes_good_hex_numeric() {
  function lexes_good_hex_lowercase (line 640) | fn lexes_good_hex_lowercase() {
  function lexes_good_hex_uppercase (line 652) | fn lexes_good_hex_uppercase() {
  function lexes_good_hex_mixed_case (line 664) | fn lexes_good_hex_mixed_case() {
  function lexes_good_hex_lowercase_long (line 676) | fn lexes_good_hex_lowercase_long() {
  function lexes_good_hex_uppercase_long (line 688) | fn lexes_good_hex_uppercase_long() {
  function does_not_lex_prefix_only (line 700) | fn does_not_lex_prefix_only() {
  function does_not_lex_bad_alphabetic (line 706) | fn does_not_lex_bad_alphabetic() {
  function does_not_lex_bad_after_good (line 712) | fn does_not_lex_bad_after_good() {
  function does_not_lex_uppercase_prefix (line 718) | fn does_not_lex_uppercase_prefix() {
  function lexes_0s (line 724) | fn lexes_0s() {
  function lexes_1_apostrophe_s (line 737) | fn lexes_1_apostrophe_s() {
  function lexes_0s_and_1s (line 750) | fn lexes_0s_and_1s() {
  function lexes_1s_and_0s_apostrophes (line 763) | fn lexes_1s_and_0s_apostrophes() {
  function doesnt_lex_0s_joined_letter (line 776) | fn doesnt_lex_0s_joined_letter() {
  function doesnt_lex_1s_apostrophe_joined_number (line 782) | fn doesnt_lex_1s_apostrophe_joined_number() {
  function lexes_20c_decade (line 788) | fn lexes_20c_decade() {
  function lexes_21c_decade (line 800) | fn lexes_21c_decade() {
  function lexes_ancient_decade (line 812) | fn lexes_ancient_decade() {
  function lexes_word_before_decade (line 824) | fn lexes_word_before_decade() {
  function lexes_word_after_decade (line 836) | fn lexes_word_after_decade() {
  function doesnt_lex_far_future_decade (line 848) | fn doesnt_lex_far_future_decade() {
  function doesnt_lex_too_ancient_decade (line 854) | fn doesnt_lex_too_ancient_decade() {
  function doesnt_lex_0_prefixed_decade (line 860) | fn doesnt_lex_0_prefixed_decade() {
  function doesnt_lex_uppercase_decade (line 866) | fn doesnt_lex_uppercase_decade() {
  function doesnt_lex_overlong_decade (line 872) | fn doesnt_lex_overlong_decade() {
  function doesnt_lex_apostrophe_long_decade (line 878) | fn doesnt_lex_apostrophe_long_decade() {
  function doesnt_lex_bad_apostrophe_short_decade (line 884) | fn doesnt_lex_bad_apostrophe_short_decade() {
  function doesnt_lex_good_apostrophe_short_decade (line 890) | fn doesnt_lex_good_apostrophe_short_decade() {
  function accepts_sentence_with_decade (line 896) | fn accepts_sentence_with_decade() {
  function rejects_sentence_with_number (line 922) | fn rejects_sentence_with_number() {
  function issue_1010 (line 954) | fn issue_1010() {
  function lexes_full_number (line 962) | fn lexes_full_number() {

FILE: harper-core/src/lexing/url.rs
  function lex_url (line 6) | pub fn lex_url(source: &[char]) -> Option<FoundToken> {
  function lex_ip_schemepart (line 29) | fn lex_ip_schemepart(source: &[char]) -> Option<usize> {
  function lex_login (line 60) | fn lex_login(source: &[char]) -> Option<usize> {
  function lex_hostport (line 85) | fn lex_hostport(source: &[char]) -> Option<usize> {
  function valid_scheme_char (line 105) | fn valid_scheme_char(c: char) -> bool {
  function is_reserved (line 109) | fn is_reserved(c: char) -> bool {
  function is_safe (line 113) | fn is_safe(c: char) -> bool {
  function is_extra (line 117) | fn is_extra(c: char) -> bool {
  function is_unreserved (line 121) | fn is_unreserved(c: char) -> bool {
  function is_hex (line 125) | fn is_hex(c: char) -> bool {
  function lex_escaped (line 130) | fn lex_escaped(source: &[char]) -> Option<usize> {
  function lex_xchar_string (line 142) | fn lex_xchar_string(source: &[char]) -> usize {
  function is_xchar_string (line 156) | fn is_xchar_string(source: &[char]) -> bool {
  function is_uchar_plus_string (line 161) | fn is_uchar_plus_string(source: &[char]) -> bool {
  function lex_xchar (line 180) | fn lex_xchar(source: &[char]) -> Option<usize> {
  function lex_uchar (line 188) | fn lex_uchar(source: &[char]) -> Option<usize> {
  function assert_consumes_full (line 202) | fn assert_consumes_full(url: &str) {
  function assert_consumes_part (line 206) | fn assert_consumes_part(url: &str, len: usize) {
  function consumes_google (line 213) | fn consumes_google() {
  function consumes_wikipedia (line 218) | fn consumes_wikipedia() {
  function consumes_youtube (line 223) | fn consumes_youtube() {
  function consumes_youtube_not_garbage (line 228) | fn consumes_youtube_not_garbage() {
  function consumes_with_path (line 233) | fn consumes_with_path() {
  function consumes_issue_142 (line 238) | fn consumes_issue_142() {
  function survives_random_chars (line 245) | fn survives_random_chars() {

FILE: harper-core/src/lib.rs
  function core_version (line 70) | pub fn core_version() -> &'static str {
  function remove_overlaps (line 78) | pub fn remove_overlaps(lints: &mut Vec<Lint>) {
  function remove_overlaps_map (line 104) | pub fn remove_overlaps_map<K: Ord>(lint_map: &mut BTreeMap<K, Vec<Lint>>) {
  function keeps_space_lint (line 180) | fn keeps_space_lint() {
  function overlap_removals_have_equivalent_behavior (line 195) | fn overlap_removals_have_equivalent_behavior(s: String) {

FILE: harper-core/src/linting/a_part.rs
  type APart (line 10) | pub struct APart {
  method default (line 15) | fn default() -> Self {
  type Unit (line 28) | type Unit = Chunk;
  method expr (line 30) | fn expr(&self) -> &dyn Expr {
  method match_to_lint (line 34) | fn match_to_lint(&self, matched_tokens: &[Token], source: &[char]) -> Op...
  method description (line 83) | fn description(&self) -> &'static str {
  function allow_normal_use_of_a_part (line 94) | fn allow_normal_use_of_a_part() {
  function allow_normal_use_of_apart (line 103) | fn allow_normal_use_of_apart() {
  function allow_normal_use_of_a_part_of (line 108) | fn allow_normal_use_of_a_part_of() {
  function allow_normal_use_of_apart_from (line 113) | fn allow_normal_use_of_apart_from() {
  function allow_normal_us_of_fall_apart (line 118) | fn allow_normal_us_of_fall_apart() {
  function allow_normal_use_of_far_apart (line 123) | fn allow_normal_use_of_far_apart() {
  function corrects_a_part_from_to_apart_from_format (line 128) | fn corrects_a_part_from_to_apart_from_format() {
  function corrects_a_part_from_to_apart_from_english (line 137) | fn corrects_a_part_from_to_apart_from_english() {
  function corrects_a_part_from_to_a_part_of (line 146) | fn corrects_a_part_from_to_a_part_of() {
  function corrects_apart_of_to_apart_from_cflinuxfs (line 155) | fn corrects_apart_of_to_apart_from_cflinuxfs() {
  function corrects_apart_of_to_apart_from_using (line 164) | fn corrects_apart_of_to_apart_from_using() {
  function corrects_apart_of_to_a_part_of_openai (line 173) | fn corrects_apart_of_to_a_part_of_openai() {
  function corrects_apart_of_to_a_part_of_formly (line 182) | fn corrects_apart_of_to_a_part_of_formly() {
  function corrects_far_a_part (line 191) | fn corrects_far_a_part() {
  function corrects_so_far_a_part_from_being_taken (line 200) | fn corrects_so_far_a_part_from_being_taken() {
  function corrects_so_far_a_part_from_version_upgrade (line 209) | fn corrects_so_far_a_part_from_version_upgrade() {
  function corrects_fall_a_part (line 218) | fn corrects_fall_a_part() {

FILE: harper-core/src/linting/a_while.rs
  type AWhile (line 11) | pub struct AWhile {
  method default (line 16) | fn default() -> Self {
  type Unit (line 50) | type Unit = Chunk;
  method expr (line 52) | fn expr(&self) -> &dyn Expr {
  method match_to_lint (line 56) | fn match_to_lint(&self, matched_tokens: &[Token], source: &[char]) -> Op...
  method description (line 71) | fn description(&self) -> &'static str {
  function allow_issue_2144 (line 83) | fn allow_issue_2144() {
  function fix_issue_2144 (line 95) | fn fix_issue_2144() {
  function correct_in_quite_a_while (line 104) | fn correct_in_quite_a_while() {
  function correct_in_a_while (line 113) | fn correct_in_a_while() {
  function correct_for_awhile (line 122) | fn correct_for_awhile() {
  function correct_after_awhile (line 131) | fn correct_after_awhile() {

FILE: harper-core/src/linting/addicting.rs
  type Addicting (line 8) | pub struct Addicting {
  method default (line 13) | fn default() -> Self {
  type Unit (line 38) | type Unit = Chunk;
  method expr (line 40) | fn expr(&self) -> &dyn Expr {
  method match_to_lint (line 44) | fn match_to_lint(&self, toks: &[Token], src: &[char]) -> Option<Lint> {
  method description (line 60) | fn description(&self) -> &str {
  function fix_addicting (line 71) | fn fix_addicting() {
  function dont_flag_addicting_object_pronoun (line 80) | fn dont_flag_addicting_object_pronoun() {
  function dont_flag_addicting_reflexive_pronoun (line 85) | fn dont_flag_addicting_reflexive_pronoun() {
  function fix_yet_highly_addicting (line 90) | fn fix_yet_highly_addicting() {
  function dont_flag_addicting_them_on (line 99) | fn dont_flag_addicting_them_on() {
  function fix_find_things_addicting_myself (line 108) | fn fix_find_things_addicting_myself() {
  function dont_fix_coerced_into_addicting_themselves (line 117) | fn dont_fix_coerced_into_addicting_themselves() {

FILE: harper-core/src/linting/adjective_double_degree.rs
  type AdjectiveDoubleDegree (line 8) | pub struct AdjectiveDoubleDegree {
  method default (line 13) | fn default() -> Self {
  type Unit (line 25) | type Unit = Chunk;
  method expr (line 27) | fn expr(&self) -> &dyn Expr {
  method match_to_lint (line 31) | fn match_to_lint(&self, toks: &[Token], src: &[char]) -> Option<Lint> {
  method description (line 105) | fn description(&self) -> &'static str {
  function fix_double_regular_superlative (line 116) | fn fix_double_regular_superlative() {
  function fix_double_regular_comparative (line 125) | fn fix_double_regular_comparative() {
  function fix_double_irregular_comparative (line 134) | fn fix_double_irregular_comparative() {
  function fix_double_irregular_superlative (line 143) | fn fix_double_irregular_superlative() {
  function conflicting_moster_offers_two_suggestions (line 152) | fn conflicting_moster_offers_two_suggestions() {
  function conflicting_morest_offers_two_suggestions (line 165) | fn conflicting_morest_offers_two_suggestions() {
  function conflicting_most_better_offers_two_suggestions (line 178) | fn conflicting_most_better_offers_two_suggestions() {
  function conflicting_most_worse_offers_two_suggestions (line 191) | fn conflicting_most_worse_offers_two_suggestions() {

FILE: harper-core/src/linting/adjective_of_a.rs
  type AdjectiveOfA (line 6) | pub struct AdjectiveOfA;
  constant ADJECTIVE_WHITELIST (line 8) | const ADJECTIVE_WHITELIST: &[&str] = &["bad", "big", "good", "large", "l...
  constant CONTEXT_WORDS (line 10) | const CONTEXT_WORDS: &[&str] = &[
  constant ADJECTIVE_BLACKLIST (line 15) | const ADJECTIVE_BLACKLIST: &[&str] = &["much", "part"];
  function has_context_word (line 17) | fn has_context_word(document: &Document, adj_idx: usize) -> bool {
  function is_good_adjective (line 44) | fn is_good_adjective(word: &str) -> bool {
  function is_bad_adjective (line 50) | fn is_bad_adjective(word: &str) -> bool {
  method lint (line 57) | fn lint(&mut self, document: &Document) -> Vec<Lint> {
  method description (line 157) | fn description(&self) -> &str {
  function correct_large_of_a (line 168) | fn correct_large_of_a() {
  function correct_bad_of_an (line 177) | fn correct_bad_of_an() {
  function dont_flag_comparative (line 186) | fn dont_flag_comparative() {
  function dont_flag_superlative (line 195) | fn dont_flag_superlative() {
  function dont_flag_kind (line 204) | fn dont_flag_kind() {
  function dont_flag_part (line 214) | fn dont_flag_part() {
  function dont_flag_much (line 224) | fn dont_flag_much() {
  function dont_flag_part_uppercase (line 234) | fn dont_flag_part_uppercase() {
  function dont_flag_all_of (line 244) | fn dont_flag_all_of() {
  function dont_flag_inside (line 254) | fn dont_flag_inside() {
  function dont_flag_out (line 264) | fn dont_flag_out() {
  function dont_flag_full (line 274) | fn dont_flag_full() {
  function dont_flag_something (line 284) | fn dont_flag_something() {
  function dont_flag_short (line 294) | fn dont_flag_short() {
  function dont_flag_bottom (line 304) | fn dont_flag_bottom() {
  function dont_flag_left (line 314) | fn dont_flag_left() {
  function dont_flag_full_uppercase (line 320) | fn dont_flag_full_uppercase() {
  function dont_flag_head (line 325) | fn dont_flag_head() {
  function dont_flag_middle (line 335) | fn dont_flag_middle() {
  function dont_flag_chance (line 345) | fn dont_flag_chance() {
  function dont_flag_potential (line 355) | fn dont_flag_potential() {
  function dont_flag_sound (line 365) | fn dont_flag_sound() {
  function dont_flag_rid (line 371) | fn dont_flag_rid() {
  function dont_flag_precision (line 378) | fn dont_flag_precision() {
  function dont_flag_back (line 388) | fn dont_flag_back() {
  function dont_flag_emblematic (line 398) | fn dont_flag_emblematic() {
  function dont_flag_half (line 408) | fn dont_flag_half() {
  function dont_flag_bit (line 414) | fn dont_flag_bit() {
  function dont_flag_dream (line 420) | fn dont_flag_dream() {
  function dont_flag_beginning (line 426) | fn dont_flag_beginning() {
  function dont_flag_side (line 432) | fn dont_flag_side() {
  function dont_flag_derivative (line 442) | fn dont_flag_derivative() {
  function dont_flag_equivalent (line 452) | fn dont_flag_equivalent() {
  function dont_flag_up (line 461) | fn dont_flag_up() {
  function dont_flag_eighth (line 470) | fn dont_flag_eighth() {
  function dont_flag_shy (line 479) | fn dont_flag_shy() {
  function dont_flag_fun (line 488) | fn dont_flag_fun() {
  function dont_flag_off (line 497) | fn dont_flag_off() {
  function dont_flag_borderline_of (line 508) | fn dont_flag_borderline_of() {
  function dont_flag_light (line 517) | fn dont_flag_light() {
  function dont_flag_multiple (line 522) | fn dont_flag_multiple() {
  function dont_flag_red (line 531) | fn dont_flag_red() {
  function dont_flag_top (line 536) | fn dont_flag_top() {
  function dont_flag_slack (line 541) | fn dont_flag_slack() {
  function dont_flag_illustrative (line 550) | fn dont_flag_illustrative() {
  function dont_flag_perspective (line 559) | fn dont_flag_perspective() {
  function correct_too_large_of_a (line 568) | fn correct_too_large_of_a() {
  function correct_too_long_of_a (line 577) | fn correct_too_long_of_a() {
  function correct_too_big_of_a (line 586) | fn correct_too_big_of_a() {
  function correct_too_vague_of_a (line 595) | fn correct_too_vague_of_a() {
  function correct_too_dumb_of_a (line 604) | fn correct_too_dumb_of_a() {
  function correct_how_important_of_a (line 613) | fn correct_how_important_of_a() {
  function correct_that_rare_of_an (line 622) | fn correct_that_rare_of_an() {
  function correct_as_important_of_a (line 631) | fn correct_as_important_of_a() {
  function correct_too_short_of_a (line 640) | fn correct_too_short_of_a() {
  function correct_that_common_of_a (line 649) | fn correct_that_common_of_a() {
  function correct_as_great_of_an (line 658) | fn correct_as_great_of_an() {
  function correct_too_uncommon_of_a (line 667) | fn correct_too_uncommon_of_a() {

FILE: harper-core/src/linting/after_later.rs
  type AfterLater (line 7) | pub struct AfterLater {
  method default (line 12) | fn default() -> Self {
  type Unit (line 43) | type Unit = Chunk;
  method expr (line 45) | fn expr(&self) -> &dyn Expr {
  method match_to_lint (line 49) | fn match_to_lint(&self, toks: &[Token], src: &[char]) -> Option<Lint> {
  method description (line 67) | fn description(&self) -> &str {
  function after_90_days_later (line 78) | fn after_90_days_later() {
  function after_about_30_minutes_later (line 87) | fn after_about_30_minutes_later() {
  function after_14_days_later (line 96) | fn after_14_days_later() {
  function after_exactly_5_minutes_later (line 105) | fn after_exactly_5_minutes_later() {
  function after_22_years_later_1 (line 114) | fn after_22_years_later_1() {
  function after_almost_2_years_later (line 123) | fn after_almost_2_years_later() {
  function after_2_years_later (line 132) | fn after_2_years_later() {
  function after_a_year_later (line 141) | fn after_a_year_later() {
  function after_22_years_later_2 (line 150) | fn after_22_years_later_2() {

FILE: harper-core/src/linting/all_hell_break_loose.rs
  type AllHellBreakLoose (line 7) | pub struct AllHellBreakLoose {
  method default (line 12) | fn default() -> Self {
  type Unit (line 26) | type Unit = Chunk;
  method match_to_lint (line 28) | fn match_to_lint(&self, toks: &[Token], src: &[char]) -> Option<Lint> {
  method description (line 42) | fn description(&self) -> &str {
  method expr (line 46) | fn expr(&self) -> &dyn Expr {
  function fix_break (line 57) | fn fix_break() {
  function fix_breaks (line 66) | fn fix_breaks() {
  function fix_breaking (line 75) | fn fix_breaking() {
  function fix_broke (line 84) | fn fix_broke() {
  function fix_broken (line 93) | fn fix_broken() {

FILE: harper-core/src/linting/all_intents_and_purposes.rs
  type AllIntentsAndPurposes (line 8) | pub struct AllIntentsAndPurposes {
  method default (line 13) | fn default() -> Self {
  type Unit (line 43) | type Unit = Chunk;
  method expr (line 45) | fn expr(&self) -> &dyn Expr {
  method match_to_lint (line 49) | fn match_to_lint(&self, toks: &[Token], src: &[char]) -> Option<Lint> {
  method description (line 91) | fn description(&self) -> &'static str {
  function fix_for_intended (line 104) | fn fix_for_intended() {
  function fix_for_intense (line 113) | fn fix_for_intense() {
  function fix_for_intensive (line 122) | fn fix_for_intensive() {
  function fix_for_intrinsic_purposes (line 131) | fn fix_for_intrinsic_purposes() {
  function fix_in_intense_purposes (line 140) | fn fix_in_intense_purposes() {
  function fix_to_intensive_purposes (line 149) | fn fix_to_intensive_purposes() {
  function fix_at_intents_and (line 160) | fn fix_at_intents_and() {
  function fix_by_intents_and (line 169) | fn fix_by_intents_and() {
  function fix_for_extents_and (line 178) | fn fix_for_extents_and() {
  function dont_flag_for_intents_and (line 187) | fn dont_flag_for_intents_and() {
  function fix_from_intents_and (line 195) | fn fix_from_intents_and() {
  function fix_in_intents_and (line 204) | fn fix_in_intents_and() {
  function fix_on_intents_and (line 213) | fn fix_on_intents_and() {
  function fix_through_intents_and (line 222) | fn fix_through_intents_and() {
  function fix_to_extents_and (line 231) | fn fix_to_extents_and() {
  function dont_flag_to_intents_and (line 240) | fn dont_flag_to_intents_and() {
  function fix_with_intents_and (line 248) | fn fix_with_intents_and() {
  function fix_by_intensive_purposes (line 259) | fn fix_by_intensive_purposes() {
  function fix_for_intense_and (line 268) | fn fix_for_intense_and() {
  function fix_in_intensive_purposes (line 277) | fn fix_in_intensive_purposes() {
  function fix_to_intense_and (line 286) | fn fix_to_intense_and() {
  function dont_flag_for_basically_all_intents_and_purposes (line 297) | fn dont_flag_for_basically_all_intents_and_purposes() {
  function dont_flag_for_nearly_all_intents_and_purposes (line 305) | fn dont_flag_for_nearly_all_intents_and_purposes() {
  function dont_flag_for_pretty_much_all_intents_and_purposes (line 313) | fn dont_flag_for_pretty_much_all_intents_and_purposes() {
  function false_positive_for_99_percent_of_all_intents_and_purposes (line 324) | fn false_positive_for_99_percent_of_all_intents_and_purposes() {
  function false_positive_for_us_constitution_space (line 334) | fn false_positive_for_us_constitution_space() {
  function false_positive_for_us_constitution_line_break (line 343) | fn false_positive_for_us_constitution_line_break() {

FILE: harper-core/src/linting/allow_to.rs
  type AllowTo (line 7) | pub struct AllowTo {
  method default (line 12) | fn default() -> Self {
  type Unit (line 26) | type Unit = Chunk;
  method expr (line 28) | fn expr(&self) -> &dyn Expr {
  method match_to_lint (line 32) | fn match_to_lint(&self, toks: &[Token], _src: &[char]) -> Option<Lint> {
  method description (line 50) | fn description(&self) -> &'static str {
  function flag_allow_to (line 61) | fn flag_allow_to() {
  function flag_allowing_to (line 70) | fn flag_allowing_to() {
  function flag_allows_to (line 79) | fn flag_allows_to() {
  function dont_flag_allowed_to (line 88) | fn dont_flag_allowed_to() {
  function dont_flag_allow_pronoun_to (line 96) | fn dont_flag_allow_pronoun_to() {
  function dont_flag_allow_noun_to (line 104) | fn dont_flag_allow_noun_to() {
  function dont_flag_allow_np_to (line 112) | fn dont_flag_allow_np_to() {

FILE: harper-core/src/linting/am_in_the_morning.rs
  type AmInTheMorning (line 9) | pub struct AmInTheMorning {
  method default (line 14) | fn default() -> Self {
  type Unit (line 44) | type Unit = Chunk;
  method expr (line 46) | fn expr(&self) -> &dyn Expr {
  method match_to_lint (line 50) | fn match_to_lint(&self, toks: &[Token], src: &[char]) -> Option<Lint> {
  method description (line 70) | fn description(&self) -> &'static str {
  function flag_at_4am_in_the_morning (line 81) | fn flag_at_4am_in_the_morning() {
  function fix_at_4am_in_the_morning (line 86) | fn fix_at_4am_in_the_morning() {
  function flag_at_4_am_in_the_morning (line 91) | fn flag_at_4_am_in_the_morning() {
  function fix_at_4_am_in_the_morning (line 96) | fn fix_at_4_am_in_the_morning() {
  function flag_at_4am_in_the_morning_caps (line 105) | fn flag_at_4am_in_the_morning_caps() {
  function fix_at_4am_in_the_morning_caps (line 110) | fn fix_at_4am_in_the_morning_caps() {
  function flag_at_4_am_in_the_morning_caps (line 115) | fn flag_at_4_am_in_the_morning_caps() {
  function fix_at_4_am_in_the_morning_caps (line 120) | fn fix_at_4_am_in_the_morning_caps() {
  function at_4_a_dot_m_dot_in_the_morning (line 129) | fn at_4_a_dot_m_dot_in_the_morning() {
  function fix_at_4_a_dot_m_dot_in_the_morning (line 134) | fn fix_at_4_a_dot_m_dot_in_the_morning() {
  function fix_real_world_1_am_in_the_morning (line 145) | fn fix_real_world_1_am_in_the_morning() {
  function fix_real_world_3am_in_the_morning (line 159) | fn fix_real_world_3am_in_the_morning() {
  function fix_real_world_3am_at_night (line 173) | fn fix_real_world_3am_at_night() {
  function fix_real_world_9pm_at_night (line 187) | fn fix_real_world_9pm_at_night() {
  function fix_real_world_3_30_am_in_the_morning (line 201) | fn fix_real_world_3_30_am_in_the_morning() {
  function fix_real_world_5_pm_in_the_afternoon_caps_dots (line 215) | fn fix_real_world_5_pm_in_the_afternoon_caps_dots() {
  function fix_real_world_5_pm_in_the_afternoon_caps (line 229) | fn fix_real_world_5_pm_in_the_afternoon_caps() {
  function fix_real_world_6_pm_in_the_evening (line 243) | fn fix_real_world_6_pm_in_the_evening() {
  function fix_real_world_4_am_in_the_morning (line 257) | fn fix_real_world_4_am_in_the_morning() {

FILE: harper-core/src/linting/amounts_for.rs
  type AmountsFor (line 9) | pub struct AmountsFor {
  method default (line 14) | fn default() -> Self {
  type Unit (line 36) | type Unit = Chunk;
  method expr (line 38) | fn expr(&self) -> &dyn Expr {
  method match_to_lint (line 42) | fn match_to_lint(&self, toks: &[Token], src: &[char]) -> Option<Lint> {
  method description (line 90) | fn description(&self) -> &str {
  function corrects_that_amounts_for_to_amounts_to_entire_value (line 101) | fn corrects_that_amounts_for_to_amounts_to_entire_value() {
  function corrects_that_amounts_for_to_amounts_to_percent (line 110) | fn corrects_that_amounts_for_to_amounts_to_percent() {
  function corrects_that_amounts_for_to_accounts_for_setting_up (line 119) | fn corrects_that_amounts_for_to_accounts_for_setting_up() {
  function corrects_which_amounts_for_to_accounts_for_16k (line 128) | fn corrects_which_amounts_for_to_accounts_for_16k() {
  function corrects_this_amounts_for_to_accounts_for_large_part (line 137) | fn corrects_this_amounts_for_to_accounts_for_large_part() {
  function corrects_they_amount_for_to_amount_to_16kb (line 146) | fn corrects_they_amount_for_to_amount_to_16kb() {
  function corrects_which_amounts_for_to_amounts_to_10_minutes (line 155) | fn corrects_which_amounts_for_to_amounts_to_10_minutes() {
  function corrects_it_amounts_for_to_amounts_to_redefinition (line 164) | fn corrects_it_amounts_for_to_amounts_to_redefinition() {
  function corrects_they_amount_for_to_amount_to_nothing (line 173) | fn corrects_they_amount_for_to_amount_to_nothing() {
  function would_amount_for_to_amount_to_api_requests (line 182) | fn would_amount_for_to_amount_to_api_requests() {
  function will_amount_for_to_amount_to_relationships (line 191) | fn will_amount_for_to_amount_to_relationships() {
  function should_amount_for_to_amount_to_half_pack (line 200) | fn should_amount_for_to_amount_to_half_pack() {
  function can_amount_for_to_amount_to_draw_calls (line 209) | fn can_amount_for_to_amount_to_draw_calls() {

FILE: harper-core/src/linting/an_a.rs
  type AnA (line 8) | pub struct AnA {
    method new (line 13) | pub fn new(dialect: Dialect) -> Self {
  method lint (line 19) | fn lint(&mut self, document: &Document) -> Vec<Lint> {
  method description (line 89) | fn description(&self) -> &'static str {
  function detects_html_as_vowel (line 101) | fn detects_html_as_vowel() {
  function detects_llm_as_vowel (line 106) | fn detects_llm_as_vowel() {
  function detects_llm_hyphen_as_vowel (line 111) | fn detects_llm_hyphen_as_vowel() {
  function detects_euler_as_vowel (line 120) | fn detects_euler_as_vowel() {
  function capitalized_fourier (line 130) | fn capitalized_fourier() {
  function once_over (line 139) | fn once_over() {
  function issue_196 (line 144) | fn issue_196() {
  function allows_lowercase_vowels (line 153) | fn allows_lowercase_vowels() {
  function allows_lowercase_consonants (line 158) | fn allows_lowercase_consonants() {
  function disallows_lowercase_vowels (line 163) | fn disallows_lowercase_vowels() {
  function disallows_lowercase_consonants (line 168) | fn disallows_lowercase_consonants() {
  function allows_uppercase_vowels (line 173) | fn allows_uppercase_vowels() {
  function allows_uppercase_consonants (line 178) | fn allows_uppercase_consonants() {
  function disallows_uppercase_vowels (line 183) | fn disallows_uppercase_vowels() {
  function disallows_uppercase_consonants (line 188) | fn disallows_uppercase_consonants() {
  function disallows_a_interface (line 193) | fn disallows_a_interface() {
  function allow_issue_751 (line 202) | fn allow_issue_751() {
  function allow_an_mp_and_an_mp3 (line 211) | fn allow_an_mp_and_an_mp3() {
  function disallow_a_mp_and_a_mp3 (line 216) | fn disallow_a_mp_and_a_mp3() {
  function recognize_acronyms (line 221) | fn recognize_acronyms() {
  function dont_misrecognize_as_acronym (line 248) | fn dont_misrecognize_as_acronym() {
  function a_udev (line 257) | fn a_udev() {
  function an_mdns (line 262) | fn an_mdns() {
  function an_rflink (line 267) | fn an_rflink() {
  function an_ffmpeg (line 272) | fn an_ffmpeg() {
  function a_honey (line 281) | fn a_honey() {
  function an_onedrive (line 286) | fn an_onedrive() {
  function a_ubiquiti (line 291) | fn a_ubiquiti() {
  function an_honest (line 300) | fn an_honest() {
  function dont_flag_an_herb_for_american (line 305) | fn dont_flag_an_herb_for_american() {
  function dont_flag_a_herb_for_british (line 310) | fn dont_flag_a_herb_for_british() {
  function correct_an_herb_for_australian (line 315) | fn correct_an_herb_for_australian() {
  function correct_a_herb_for_canadian (line 320) | fn correct_a_herb_for_canadian() {
  function dont_flag_a_sql (line 325) | fn dont_flag_a_sql() {
  function dont_flag_an_sql (line 330) | fn dont_flag_an_sql() {
  function allow_an_and_a_for_led_2550 (line 335) | fn allow_an_and_a_for_led_2550() {

FILE: harper-core/src/linting/and_in.rs
  type AndIn (line 6) | pub struct AndIn {
  method default (line 11) | fn default() -> Self {
  type Unit (line 19) | type Unit = Chunk;
  method expr (line 21) | fn expr(&self) -> &dyn Expr {
  method match_to_lint (line 25) | fn match_to_lint(&self, toks: &[Token], src: &[char]) -> Option<Lint> {
  method description (line 42) | fn description(&self) -> &str {
  function dont_flag_an_in_house (line 53) | fn dont_flag_an_in_house() {
  function dont_flag_an_in_memory (line 61) | fn dont_flag_an_in_memory() {
  function dont_flag_an_in_the_moment (line 69) | fn dont_flag_an_in_the_moment() {
  function fix_an_in_to_and_in (line 77) | fn fix_an_in_to_and_in() {
  function dont_flag_an_in_with_company (line 87) | fn dont_flag_an_in_with_company() {

FILE: harper-core/src/linting/and_the_like.rs
  type AndTheLike (line 8) | pub struct AndTheLike {
  method default (line 13) | fn default() -> Self {
  type Unit (line 39) | type Unit = Chunk;
  method expr (line 41) | fn expr(&self) -> &dyn Expr {
  method match_to_lint (line 45) | fn match_to_lint(&self, toks: &[Token], src: &[char]) -> Option<Lint> {
  method description (line 68) | fn description(&self) -> &str {
  function dont_flag_and_the_like (line 79) | fn dont_flag_and_the_like() {
  function dont_flag_or_the_like (line 87) | fn dont_flag_or_the_like() {
  function flag_an_the_likes (line 95) | fn flag_an_the_likes() {
  function flag_and_alike (line 104) | fn flag_and_alike() {
  function flag_and_alikes (line 113) | fn flag_and_alikes() {
  function flag_and_the_alike (line 122) | fn flag_and_the_alike() {
  function flag_and_the_likes (line 131) | fn flag_and_the_likes() {
  function flag_or_alike (line 140) | fn flag_or_alike() {
  function flag_or_alikes (line 149) | fn flag_or_alikes() {
  function flag_or_the_likes (line 158) | fn flag_or_the_likes() {

FILE: harper-core/src/linting/another_thing_coming.rs
  type AnotherThingComing (line 9) | pub struct AnotherThingComing {
  method default (line 14) | fn default() -> Self {
  type Unit (line 23) | type Unit = Chunk;
  method expr (line 25) | fn expr(&self) -> &dyn Expr {
  method match_to_lint (line 29) | fn match_to_lint(&self, toks: &[Token], src: &[char]) -> Option<Lint> {
  method description (line 42) | fn description(&self) -> &str {
  function fix_have_another_think_coming (line 53) | fn fix_have_another_think_coming() {
  function fix_has_another_think_coming (line 62) | fn fix_has_another_think_coming() {
  function fix_got_another_think_coming (line 72) | fn fix_got_another_think_coming() {
  function fix_had_another_think_coming (line 81) | fn fix_had_another_think_coming() {

FILE: harper-core/src/linting/another_think_coming.rs
  type AnotherThinkComing (line 9) | pub struct AnotherThinkComing {
  method default (line 14) | fn default() -> Self {
  type Unit (line 23) | type Unit = Chunk;
  method expr (line 25) | fn expr(&self) -> &dyn Expr {
  method match_to_lint (line 29) | fn match_to_lint(&self, toks: &[Token], src: &[char]) -> Option<Lint> {
  method description (line 42) | fn description(&self) -> &str {
  function fix_got_another_thing_coming (line 53) | fn fix_got_another_thing_coming() {
  function fix_has_another_thing_coming (line 62) | fn fix_has_another_thing_coming() {
  function fix_have_another_thing_coming (line 71) | fn fix_have_another_thing_coming() {
  function fix_had_another_thing_coming (line 80) | fn fix_had_another_thing_coming() {

FILE: harper-core/src/linting/apart_from.rs
  type ApartFrom (line 7) | pub struct ApartFrom {
  method default (line 12) | fn default() -> Self {
  type Unit (line 22) | type Unit = Chunk;
  method expr (line 24) | fn expr(&self) -> &dyn Expr {
  method match_to_lint (line 28) | fn match_to_lint(&self, matched_tokens: &[Token], source: &[char]) -> Op...
  method description (line 43) | fn description(&self) -> &'static str {
  function corrects_basic_typo (line 54) | fn corrects_basic_typo() {
  function corrects_title_case (line 63) | fn corrects_title_case() {
  function corrects_all_caps (line 72) | fn corrects_all_caps() {
  function corrects_with_comma (line 81) | fn corrects_with_comma() {
  function corrects_with_newline (line 90) | fn corrects_with_newline() {
  function corrects_extra_spacing (line 99) | fn corrects_extra_spacing() {
  function allows_correct_phrase (line 108) | fn allows_correct_phrase() {
  function ignores_hyphenated (line 117) | fn ignores_hyphenated() {
  function ignores_split_by_comma (line 126) | fn ignores_split_by_comma() {
  function ignores_unrelated_form_usage (line 135) | fn ignores_unrelated_form_usage() {

FILE: harper-core/src/linting/ask_no_preposition.rs
  type AskNoPreposition (line 10) | pub struct AskNoPreposition {
  method default (line 15) | fn default() -> Self {
  type Unit (line 33) | type Unit = Chunk;
  method expr (line 35) | fn expr(&self) -> &dyn Expr {
  method match_to_lint (line 39) | fn match_to_lint(&self, toks: &[Token], src: &[char]) -> Option<Lint> {
  method description (line 58) | fn description(&self) -> &str {
  function flags_ask (line 69) | fn flags_ask() {
  function flags_ask_all_caps (line 78) | fn flags_ask_all_caps() {
  function flags_tell (line 87) | fn flags_tell() {
  function ignores_correct_usage (line 96) | fn ignores_correct_usage() {
  function flags_ask_us (line 105) | fn flags_ask_us() {
  function flags_asks_him (line 114) | fn flags_asks_him() {
  function flags_asked_me (line 123) | fn flags_asked_me() {
  function flags_told_one (line 132) | fn flags_told_one() {
  function flags_telling_it (line 141) | fn flags_telling_it() {
  function flags_tells_them (line 150) | fn flags_tells_them() {
  function flags_telling_him (line 159) | fn flags_telling_him() {
  function flags_asking_you (line 168) | fn flags_asking_you() {
  function ignores_ask_question (line 177) | fn ignores_ask_question() {
  function ignores_told_to_leave (line 186) | fn ignores_told_to_leave() {
  function ignores_tell_us (line 195) | fn ignores_tell_us() {
  function ignores_ask_about (line 200) | fn ignores_ask_about() {

FILE: harper-core/src/linting/avoid_curses.rs
  type AvoidCurses (line 8) | pub struct AvoidCurses {
  method default (line 13) | fn default() -> Self {
  type Unit (line 21) | type Unit = Chunk;
  method expr (line 23) | fn expr(&self) -> &dyn Expr {
  method match_to_lint (line 27) | fn match_to_lint(&self, toks: &[Token], src: &[char]) -> Option<Lint> {
  method description (line 246) | fn description(&self) -> &'static str {
  function detects_shit (line 257) | fn detects_shit() {
  function fix_shit (line 266) | fn fix_shit() {
  function fix_shit_titlecase (line 271) | fn fix_shit_titlecase() {
  function fix_shit_allcaps (line 276) | fn fix_shit_allcaps() {
  function fix_f_word_to_all_asterisks (line 281) | fn fix_f_word_to_all_asterisks() {
  function fix_shit_with_single_asterisk (line 290) | fn fix_shit_with_single_asterisk() {
  function fix_shite_all_caps_with_single_asterisk (line 295) | fn fix_shite_all_caps_with_single_asterisk() {

FILE: harper-core/src/linting/back_in_the_day.rs
  type BackInTheDay (line 14) | pub struct BackInTheDay {
  method default (line 21) | fn default() -> Self {
  type Unit (line 38) | type Unit = Chunk;
  method expr (line 40) | fn expr(&self) -> &dyn Expr {
  method match_to_lint (line 44) | fn match_to_lint(&self, matched_tokens: &[Token], source: &[char]) -> Op...
  method description (line 66) | fn description(&self) -> &'static str {
  function detects_gem_update_case (line 77) | fn detects_gem_update_case() {
  function detects_install_case (line 86) | fn detects_install_case() {
  function detects_composer_json_case (line 95) | fn detects_composer_json_case() {
  function detects_version_release_case (line 104) | fn detects_version_release_case() {
  function avoids_false_positive_springfox (line 113) | fn avoids_false_positive_springfox() {
  function avoids_false_positive_ie (line 122) | fn avoids_false_positive_ie() {
  function avoids_false_positive_code_usage (line 131) | fn avoids_false_positive_code_usage() {
  function catches_uppercase (line 139) | fn catches_uppercase() {
  function catches_lowercase (line 148) | fn catches_lowercase() {
  function doesnt_catch_false_positive_of (line 157) | fn doesnt_catch_false_positive_of() {
  function doesnt_catch_false_positive_when (line 166) | fn doesnt_catch_false_positive_when() {
  function catches_comma_when (line 175) | fn catches_comma_when() {
  function doesnt_catch_false_positive_before (line 184) | fn doesnt_catch_false_positive_before() {
  function catches_comma_before (line 193) | fn catches_comma_before() {
  function doesnt_catch_qualified_days (line 202) | fn doesnt_catch_qualified_days() {

FILE: harper-core/src/linting/be_allowed.rs
  type BeAllowed (line 8) | pub struct BeAllowed {
  method default (line 13) | fn default() -> Self {
  type Unit (line 47) | type Unit = Chunk;
  method expr (line 49) | fn expr(&self) -> &dyn Expr {
  method match_to_lint (line 53) | fn match_to_lint(&self, matched_tokens: &[Token], source: &[char]) -> Op...
  method description (line 71) | fn description(&self) -> &'static str {
  function corrects_basic_sentence (line 83) | fn corrects_basic_sentence() {
  function corrects_first_person_subject (line 92) | fn corrects_first_person_subject() {
  function corrects_plural_subject (line 101) | fn corrects_plural_subject() {
  function corrects_with_intro_clause (line 110) | fn corrects_with_intro_clause() {
  function corrects_contracted_form (line 119) | fn corrects_contracted_form() {
  function corrects_all_caps (line 128) | fn corrects_all_caps() {
  function corrects_with_trailing_clause (line 137) | fn corrects_with_trailing_clause() {
  function corrects_with_modal_context (line 146) | fn corrects_with_modal_context() {
  function leaves_correct_phrase_untouched (line 155) | fn leaves_correct_phrase_untouched() {
  function leaves_other_verbs_alone (line 164) | fn leaves_other_verbs_alone() {
  function leaves_similar_sequence_without_to (line 173) | fn leaves_similar_sequence_without_to() {

FILE: harper-core/src/linting/be_worried.rs
  type BeWorried (line 11) | pub struct BeWorried {
  method default (line 16) | fn default() -> Self {
  type Unit (line 38) | type Unit = Chunk;
  method expr (line 40) | fn expr(&self) -> &dyn Expr {
  method match_to_lint_with_context (line 44) | fn match_to_lint_with_context(
  method description (line 74) | fn description(&self) -> &'static str {
  function he_is (line 88) | fn he_is() {
  function he_was (line 97) | fn he_was() {
  function i_am (line 106) | fn i_am() {
  function i_was (line 115) | fn i_was() {
  function i_were (line 124) | fn i_were() {
  function they_are (line 133) | fn they_are() {
  function theyre_worry (line 142) | fn theyre_worry() {
  function we_are (line 151) | fn we_are() {
  function were (line 160) | fn were() {
  function you_are (line 169) | fn you_are() {
  function youre (line 178) | fn youre() {
  function dont_flag_it_is (line 187) | fn dont_flag_it_is() {
  function dont_flag_it_was (line 195) | fn dont_flag_it_was() {
  function dont_flag_she_was_worry_free (line 203) | fn dont_flag_she_was_worry_free() {
  function dont_flag_theyre_worry_free (line 208) | fn dont_flag_theyre_worry_free() {
  function dont_flag_worry_warts (line 216) | fn dont_flag_worry_warts() {
  function dont_flag_were_worry_space_free (line 224) | fn dont_flag_were_worry_space_free() {
  function cant_fix_edge_case_yet (line 233) | fn cant_fix_edge_case_yet() {

FILE: harper-core/src/linting/behind_the_scenes.rs
  type BehindTheScenes (line 7) | pub struct BehindTheScenes {
  method default (line 12) | fn default() -> Self {
  type Unit (line 24) | type Unit = Chunk;
  method description (line 26) | fn description(&self) -> &str {
  method expr (line 30) | fn expr(&self) -> &dyn Expr {
  method match_to_lint_with_context (line 34) | fn match_to_lint_with_context(
  function pluralize_work_bts (line 69) | fn pluralize_work_bts() {
  function pluralize_and_hyphenate (line 79) | fn pluralize_and_hyphenate() {
  function dont_flag_when_hyphenated_to_previous_word (line 88) | fn dont_flag_when_hyphenated_to_previous_word() {
  function pluralize_bts_processing (line 96) | fn pluralize_bts_processing() {

FILE: harper-core/src/linting/best_of_all_time.rs
  type BestOfAllTime (line 5) | pub struct BestOfAllTime {
  method default (line 10) | fn default() -> Self {
  type Unit (line 44) | type Unit = Sentence;
  method expr (line 46) | fn expr(&self) -> &dyn Expr {
  method match_to_lint (line 50) | fn match_to_lint(&self, toks: &[Token], src: &[char]) -> Option<Lint> {
  method description (line 66) | fn description(&self) -> &'static str {
  function dont_flag_list_of_all_times (line 78) | fn dont_flag_list_of_all_times() {
  function fix_after_best (line 87) | fn fix_after_best() {
  function fix_after_greatest (line 96) | fn fix_after_greatest() {
  function fix_after_biggest (line 105) | fn fix_after_biggest() {
  function fix_after_most_influential (line 114) | fn fix_after_most_influential() {
  function dont_flag_sum_of_all_times (line 123) | fn dont_flag_sum_of_all_times() {
  function dont_flag_history_stacks_of_all_times (line 132) | fn dont_flag_history_stacks_of_all_times() {
  function fix_after_favorite (line 141) | fn fix_after_favorite() {
  function fix_after_favourite (line 150) | fn fix_after_favourite() {
  function fix_top_out_of_vocabulary (line 159) | fn fix_top_out_of_vocabulary() {
  function fix_compound_noun (line 168) | fn fix_compound_noun() {
  function fix_containing_commas (line 177) | fn fix_containing_commas() {

FILE: harper-core/src/linting/boring_words.rs
  type BoringWords (line 10) | pub struct BoringWords {
  method default (line 15) | fn default() -> Self {
  type Unit (line 29) | type Unit = Chunk;
  method expr (line 31) | fn expr(&self) -> &dyn Expr {
  method match_to_lint (line 35) | fn match_to_lint(&self, matched_tokens: &[Token], source: &[char]) -> Op...
  method description (line 54) | fn description(&self) -> &'static str {

FILE: harper-core/src/linting/bought.rs
  type Bought (line 7) | pub struct Bought {
    method is_subject_pronoun_like (line 52) | fn is_subject_pronoun_like(token: &Token, source: &[char]) -> bool {
  method default (line 12) | fn default() -> Self {
  type Unit (line 25) | type Unit = Chunk;
  method expr (line 27) | fn expr(&self) -> &dyn Expr {
  method match_to_lint (line 31) | fn match_to_lint(&self, matched_tokens: &[Token], source: &[char]) -> Op...
  method description (line 46) | fn description(&self) -> &'static str {
  function corrects_he_bough (line 81) | fn corrects_he_bough() {
  function corrects_she_never_bough (line 90) | fn corrects_she_never_bough() {
  function corrects_they_already_bough (line 99) | fn corrects_they_already_bough() {
  function corrects_we_have_bough (line 108) | fn corrects_we_have_bough() {
  function corrects_they_have_never_bough (line 117) | fn corrects_they_have_never_bough() {
  function corrects_ive_bough (line 126) | fn corrects_ive_bough() {
  function corrects_wed_bough (line 135) | fn corrects_wed_bough() {
  function no_lint_for_tree_bough (line 144) | fn no_lint_for_tree_bough() {
  function no_lint_for_he_bought (line 149) | fn no_lint_for_he_bought() {
  function no_lint_for_plural_boughs (line 154) | fn no_lint_for_plural_boughs() {

FILE: harper-core/src/linting/brand_brandish.rs
  type BrandBrandish (line 7) | pub struct BrandBrandish {
  method default (line 12) | fn default() -> Self {
  type Unit (line 24) | type Unit = Chunk;
  method expr (line 26) | fn expr(&self) -> &dyn Expr {
  method match_to_lint (line 30) | fn match_to_lint(&self, toks: &[Token], src: &[char]) -> Option<Lint> {
  method description (line 66) | fn description(&self) -> &str {
  function correct_brandish_a_traitor (line 76) | fn correct_brandish_a_traitor() {
  function correct_brandish_a_criminal (line 85) | fn correct_brandish_a_criminal() {
  function correct_brandish_as_a (line 94) | fn correct_brandish_as_a() {
  function correct_brandish_an_offender (line 103) | fn correct_brandish_an_offender() {
  function correct_brandish_with_nicknames (line 112) | fn correct_brandish_with_nicknames() {
  function correct_brandish_as_a_aymbol (line 121) | fn correct_brandish_as_a_aymbol() {
  function correct_brandish_as_illegal (line 130) | fn correct_brandish_as_illegal() {
  function correct_brandish_with_nickname (line 139) | fn correct_brandish_with_nickname() {
  function correct_brandish_with_label (line 148) | fn correct_brandish_with_label() {
  function correct_brandished_us (line 157) | fn correct_brandished_us() {
  function correct_brandishing_him (line 166) | fn correct_brandishing_him() {
  function correct_brandish_us (line 175) | fn correct_brandish_us() {
  function correct_brandished_him (line 184) | fn correct_brandished_him() {
  function correct_brandishes_him (line 193) | fn correct_brandishes_him() {

FILE: harper-core/src/linting/by_accident.rs
  type ByAccident (line 12) | pub struct ByAccident {
  method default (line 17) | fn default() -> Self {
  type Unit (line 33) | type Unit = Chunk;
  method description (line 35) | fn description(&self) -> &str {
  method expr (line 39) | fn expr(&self) -> &dyn Expr {
  method match_to_lint (line 43) | fn match_to_lint(&self, toks: &[Token], src: &[char]) -> Option<Lint> {
  function fix_on_accident (line 66) | fn fix_on_accident() {
  function fix_on_complete_accident (line 75) | fn fix_on_complete_accident() {
  function fix_on_happy_accident (line 84) | fn fix_on_happy_accident() {
  function fix_on_literal_accident (line 93) | fn fix_on_literal_accident() {
  function fix_on_mere_accident (line 102) | fn fix_on_mere_accident() {
  function fix_on_pure_accident (line 111) | fn fix_on_pure_accident() {
  function fix_on_sheer_accident (line 120) | fn fix_on_sheer_accident() {
  function fix_on_total_accident (line 129) | fn fix_on_total_accident() {

FILE: harper-core/src/linting/call_them.rs
  type CallThem (line 10) | pub struct CallThem {
  method default (line 15) | fn default() -> Self {
  type Unit (line 45) | type Unit = Chunk;
  method expr (line 47) | fn expr(&self) -> &dyn Expr {
  method match_to_lint (line 51) | fn match_to_lint(&self, matched_tokens: &[Token], source: &[char]) -> Op...
  method description (line 64) | fn description(&self) -> &'static str {
  function prefer_plug_and_receptacle (line 78) | fn prefer_plug_and_receptacle() {
  function builtins_id (line 87) | fn builtins_id() {
  function non_modal_dialogue (line 96) | fn non_modal_dialogue() {
  function prefer_to_call_them (line 105) | fn prefer_to_call_them() {
  function called_them_allies (line 114) | fn called_them_allies() {
  function character_development (line 123) | fn character_development() {
  function fate_or_time (line 132) | fn fate_or_time() {
  function abstract_latte_art (line 141) | fn abstract_latte_art() {
  function sounding_boards (line 150) | fn sounding_boards() {
  function calling_them_disaster (line 159) | fn calling_them_disaster() {
  function battle_of_boxes (line 168) | fn battle_of_boxes() {
  function called_her_shinnasan (line 177) | fn called_her_shinnasan() {
  function calling_it_otp (line 186) | fn calling_it_otp() {
  function call_it_procrastination (line 195) | fn call_it_procrastination() {
  function call_her_important (line 204) | fn call_her_important() {
  function call_him_kindles (line 213) | fn call_him_kindles() {
  function call_them_defenders (line 222) | fn call_them_defenders() {
  function call_it_magical (line 231) | fn call_it_magical() {
  function forward_lateral (line 240) | fn forward_lateral() {
  function calling_best_friend (line 249) | fn calling_best_friend() {
  function calling_everyone_titles (line 258) | fn calling_everyone_titles() {
  function called_as_he (line 267) | fn called_as_he() {
  function calls_him_bob (line 276) | fn calls_him_bob() {
  function pliny_called_it (line 285) | fn pliny_called_it() {
  function students_call_you (line 294) | fn students_call_you() {
  function paradoxical_reaction (line 303) | fn paradoxical_reaction() {
  function rust_module (line 312) | fn rust_module() {
  function want_to_do (line 320) | fn want_to_do() {

FILE: harper-core/src/linting/cant.rs
  type Cant (line 9) | pub struct Cant {
  method default (line 14) | fn default() -> Self {
  type Unit (line 35) | type Unit = Chunk;
  method expr (line 37) | fn expr(&self) -> &dyn Expr {
  method match_to_lint (line 41) | fn match_to_lint(&self, toks: &[Token], src: &[char]) -> Option<Lint> {
  method description (line 60) | fn description(&self) -> &'static str {
  function corrects_pronoun_cant (line 71) | fn corrects_pronoun_cant() {
  function corrects_proper_noun_cant (line 80) | fn corrects_proper_noun_cant() {
  function corrects_common_noun_cant (line 89) | fn corrects_common_noun_cant() {
  function corrects_cant_pronoun (line 99) | fn corrects_cant_pronoun() {
  function dont_flag_if_cant_is_part_of_noun_phrase (line 108) | fn dont_flag_if_cant_is_part_of_noun_phrase() {
  function dont_flag_cant_project (line 113) | fn dont_flag_cant_project() {
  function corrects_cant_verb (line 123) | fn corrects_cant_verb() {
  function dont_flag_legit_noun_sense (line 132) | fn dont_flag_legit_noun_sense() {

FILE: harper-core/src/linting/capitalize_personal_pronouns.rs
  type CapitalizePersonalPronouns (line 7) | pub struct CapitalizePersonalPronouns;
  method lint (line 10) | fn lint(&mut self, document: &crate::Document) -> Vec<Lint> {
  method description (line 42) | fn description(&self) -> &'static str {
  function start (line 54) | fn start() {
  function end (line 59) | fn end() {
  function middle (line 68) | fn middle() {
  function issue_365 (line 77) | fn issue_365() {
  function corrects_id (line 86) | fn corrects_id() {
  function correct_real_world_id (line 91) | fn correct_real_world_id() {
  function corrects_idve (line 100) | fn corrects_idve() {
  function correct_real_world_idve (line 105) | fn correct_real_world_idve() {
  function corrects_ill (line 114) | fn corrects_ill() {
  function correct_real_world_ill (line 119) | fn correct_real_world_ill() {
  function corrects_im (line 128) | fn corrects_im() {
  function correct_real_world_im (line 133) | fn correct_real_world_im() {
  function corrects_ive (line 142) | fn corrects_ive() {
  function correct_real_world_ive (line 147) | fn correct_real_world_ive() {

FILE: harper-core/src/linting/cautionary_tale.rs
  type CautionaryTale (line 11) | pub struct CautionaryTale {
  method default (line 16) | fn default() -> Self {
  type Unit (line 26) | type Unit = Chunk;
  method expr (line 28) | fn expr(&self) -> &dyn Expr {
  method match_to_lint (line 32) | fn match_to_lint(&self, toks: &[Token], src: &[char]) -> Option<Lint> {
  method description (line 48) | fn description(&self) -> &'static str {
  function catches_cautionary_tail (line 59) | fn catches_cautionary_tail() {
  function catches_inspirational_tail (line 68) | fn catches_inspirational_tail() {
  function catches_capitalized_cautionary_tail (line 77) | fn catches_capitalized_cautionary_tail() {
  function catches_uppercase_cautionary_tail (line 86) | fn catches_uppercase_cautionary_tail() {
  function catches_mixed_case (line 95) | fn catches_mixed_case() {
  function allows_actual_tail (line 104) | fn allows_actual_tail() {
  function allows_different_adjective_with_tail (line 113) | fn allows_different_adjective_with_tail() {
  function allows_correct_tale (line 118) | fn allows_correct_tale() {
  function allows_inspirational_tale (line 127) | fn allows_inspirational_tale() {
  function catches_in_longer_text (line 136) | fn catches_in_longer_text() {
  function catches_multiple_occurrences (line 145) | fn catches_multiple_occurrences() {
  function allows_tail_in_different_context (line 154) | fn allows_tail_in_different_context() {
  function catches_at_start_of_sentence (line 163) | fn catches_at_start_of_sentence() {

FILE: harper-core/src/linting/change_tack.rs
  type ChangeTack (line 8) | pub struct ChangeTack {
  method default (line 13) | fn default() -> Self {
  type Unit (line 40) | type Unit = Chunk;
  method expr (line 42) | fn expr(&self) -> &dyn Expr {
  method match_to_lint (line 46) | fn match_to_lint(&self, toks: &[Token], src: &[char]) -> Option<Lint> {
  method description (line 63) | fn description(&self) -> &'static str {
  function change_tact_atomic (line 76) | fn change_tact_atomic() {
  function changed_tacks_atomic (line 81) | fn changed_tacks_atomic() {
  function changes_tacts_atomic (line 86) | fn changes_tacts_atomic() {
  function changing_tact_atomic (line 91) | fn changing_tact_atomic() {
  function change_of_tacks_atomic (line 98) | fn change_of_tacks_atomic() {
  function change_of_tact_real_world (line 103) | fn change_of_tact_real_world() {
  function change_of_tacts_real_world (line 112) | fn change_of_tacts_real_world() {
  function changing_of_tacks_real_world (line 121) | fn changing_of_tacks_real_world() {
  function changes_of_tact_real_world (line 130) | fn changes_of_tact_real_world() {
  function changed_my_tact (line 141) | fn changed_my_tact() {
  function changed_our_tact (line 150) | fn changed_our_tact() {
  function change_your_tact (line 159) | fn change_your_tact() {
  function change_his_tact (line 168) | fn change_his_tact() {
  function changed_her_tact (line 177) | fn changed_her_tact() {
  function change_its_tact (line 186) | fn change_its_tact() {
  function changing_its_tact_apostrophe (line 195) | fn changing_its_tact_apostrophe() {
  function changes_their_tact (line 204) | fn changes_their_tact() {
  function different_tact (line 213) | fn different_tact() {

FILE: harper-core/src/linting/chock_full.rs
  type ChockFull (line 8) | pub struct ChockFull {
  method default (line 13) | fn default() -> Self {
  type Unit (line 21) | type Unit = Chunk;
  method expr (line 23) | fn expr(&self) -> &dyn Expr {
  method match_to_lint (line 27) | fn match_to_lint(&self, matched_toks: &[Token], source: &[char]) -> Opti...
  method description (line 49) | fn description(&self) -> &'static str {
  function allows_correct_form (line 60) | fn allows_correct_form() {
  function lower_space_chalk (line 69) | fn lower_space_chalk() {
  function lower_space_choke (line 78) | fn lower_space_choke() {
  function upper_space_chalk (line 87) | fn upper_space_chalk() {
  function upper_space_choke (line 96) | fn upper_space_choke() {
  function lower_hyphen_chalk (line 105) | fn lower_hyphen_chalk() {
  function lower_hyphen_choke (line 114) | fn lower_hyphen_choke() {
  function upper_hyphen_chalk (line 123) | fn upper_hyphen_chalk() {
  function upper_hyphen_choke (line 132) | fn upper_hyphen_choke() {

FILE: harper-core/src/linting/closed_compounds.rs
  function lint_group (line 5) | pub fn lint_group() -> LintGroup {
  function it_self (line 96) | fn it_self() {
  function my_self (line 103) | fn my_self() {
  function there_fore (line 110) | fn there_fore() {
  function mis_understood (line 117) | fn mis_understood() {
  function mis_use (line 124) | fn mis_use() {
  function mis_used (line 131) | fn mis_used() {
  function world_wide (line 138) | fn world_wide() {
  function over_all (line 145) | fn over_all() {
  function how_ever (line 152) | fn how_ever() {
  function wide_spread (line 159) | fn wide_spread() {
  function not_with_standing (line 166) | fn not_with_standing() {
  function any_how (line 173) | fn any_how() {
  function none_the_less (line 180) | fn none_the_less() {
  function there_upon (line 187) | fn there_upon() {
  function in_so_far (line 194) | fn in_so_far() {
  function where_upon (line 201) | fn where_upon() {
  function up_ward (line 208) | fn up_ward() {
  function hence_forth (line 215) | fn hence_forth() {
  function regard_less (line 222) | fn regard_less() {
  function over_night (line 229) | fn over_night() {
  function by_pass (line 236) | fn by_pass() {
  function dead_lift (line 243) | fn dead_lift() {
  function chalk_board (line 250) | fn chalk_board() {
  function key_stoke (line 257) | fn key_stoke() {
  function in_tact (line 264) | fn in_tact() {
  function intact_is_allowed (line 271) | fn intact_is_allowed() {
  function key_stokes (line 276) | fn key_stokes() {
  function with_out (line 283) | fn with_out() {
  function the_re (line 290) | fn the_re() {
  function short_coming (line 297) | fn short_coming() {
  function short_comings (line 304) | fn short_comings() {

FILE: harper-core/src/linting/comma_fixes.rs
  constant MSG_SPACE_BEFORE (line 8) | const MSG_SPACE_BEFORE: &str = "Don't use a space before a comma.";
  constant MSG_AVOID_ASIAN (line 9) | const MSG_AVOID_ASIAN: &str = "Avoid East Asian commas in English contex...
  constant MSG_SPACE_AFTER (line 10) | const MSG_SPACE_AFTER: &str = "Use a space after a comma.";
  type CommaFixes (line 22) | pub struct CommaFixes;
  method lint (line 25) | fn lint(&mut self, document: &crate::Document) -> Vec<Lint> {
  method description (line 113) | fn description(&self) -> &'static str {
  function allows_english_comma_atomic (line 124) | fn allows_english_comma_atomic() {
  function flags_fullwidth_comma_atomic (line 129) | fn flags_fullwidth_comma_atomic() {
  function flags_ideographic_comma_atomic (line 134) | fn flags_ideographic_comma_atomic() {
  function corrects_fullwidth_comma_real_world (line 139) | fn corrects_fullwidth_comma_real_world() {
  function corrects_ideographic_comma_real_world (line 148) | fn corrects_ideographic_comma_real_world() {
  function doesnt_flag_comma_space_between_words (line 153) | fn doesnt_flag_comma_space_between_words() {
  function flags_fullwidth_comma_space_between_words (line 158) | fn flags_fullwidth_comma_space_between_words() {
  function flags_ideographic_comma_space_between_words (line 163) | fn flags_ideographic_comma_space_between_words() {
  function doesnt_flag_semicolon_space_between_words (line 168) | fn doesnt_flag_semicolon_space_between_words() {
  function corrects_comma_between_words_with_no_space (line 173) | fn corrects_comma_between_words_with_no_space() {
  function corrects_asian_comma_between_words_with_no_space (line 178) | fn corrects_asian_comma_between_words_with_no_space() {
  function corrects_space_on_wrong_side_of_comma_between_words (line 183) | fn corrects_space_on_wrong_side_of_comma_between_words() {
  function corrects_comma_on_wrong_side_of_asian_comma_between_words (line 188) | fn corrects_comma_on_wrong_side_of_asian_comma_between_words() {
  function corrects_comma_between_words_with_space_on_both_sides (line 193) | fn corrects_comma_between_words_with_space_on_both_sides() {
  function corrects_asian_comma_between_words_with_space_on_both_sides (line 198) | fn corrects_asian_comma_between_words_with_space_on_both_sides() {
  function doesnt_correct_comma_between_non_english_tokens (line 203) | fn doesnt_correct_comma_between_non_english_tokens() {
  function issue_2233 (line 208) | fn issue_2233() {

FILE: harper-core/src/linting/compound_nouns/compound_noun_after_det_adj.rs
  type CompoundNounAfterDetAdj (line 15) | pub struct CompoundNounAfterDetAdj {
  method default (line 26) | fn default() -> Self {
  type Unit (line 52) | type Unit = Chunk;
  method expr (line 54) | fn expr(&self) -> &dyn Expr {
  method match_to_lint (line 58) | fn match_to_lint(&self, matched_tokens: &[Token], source: &[char]) -> Op...
  method description (line 87) | fn description(&self) -> &str {

FILE: harper-core/src/linting/compound_nouns/compound_noun_after_possessive.rs
  type CompoundNounAfterPossessive (line 19) | pub struct CompoundNounAfterPossessive {
  method default (line 25) | fn default() -> Self {
  type Unit (line 50) | type Unit = Chunk;
  method expr (line 52) | fn expr(&self) -> &dyn Expr {
  method match_to_lint (line 56) | fn match_to_lint(&self, matched_tokens: &[Token], source: &[char]) -> Op...
  method description (line 86) | fn description(&self) -> &str {
  function lets_is_not_possessive (line 97) | fn lets_is_not_possessive() {
  function lets_is_not_possessive_typographic_apostrophe (line 106) | fn lets_is_not_possessive_typographic_apostrophe() {
  function thats_is_not_possessive (line 115) | fn thats_is_not_possessive() {

FILE: harper-core/src/linting/compound_nouns/compound_noun_before_aux_verb.rs
  type CompoundNounBeforeAuxVerb (line 13) | pub struct CompoundNounBeforeAuxVerb {
  method default (line 19) | fn default() -> Self {
  type Unit (line 41) | type Unit = Chunk;
  method expr (line 43) | fn expr(&self) -> &dyn Expr {
  method match_to_lint (line 47) | fn match_to_lint(&self, matched_tokens: &[Token], source: &[char]) -> Op...
  method description (line 68) | fn description(&self) -> &str {

FILE: harper-core/src/linting/compound_nouns/mod.rs
  function is_content_word (line 9) | pub(crate) fn is_content_word(tok: &Token, src: &[char]) -> bool {
  function predicate (line 20) | pub(crate) fn predicate(
  function web_cam (line 39) | fn web_cam() {
  function note_book (line 46) | fn note_book() {
  function mother_board (line 53) | fn mother_board() {
  function smart_phone (line 60) | fn smart_phone() {
  function firm_ware (line 67) | fn firm_ware() {
  function back_plane (line 74) | fn back_plane() {
  function spread_sheet (line 81) | fn spread_sheet() {
  function side_bar (line 88) | fn side_bar() {
  function back_pack (line 95) | fn back_pack() {
  function cup_board (line 102) | fn cup_board() {
  function key_board (line 109) | fn key_board() {
  function touch_screen (line 116) | fn touch_screen() {
  function head_set (line 123) | fn head_set() {
  function frame_work (line 130) | fn frame_work() {
  function touch_pad (line 137) | fn touch_pad() {
  function micro_processor (line 144) | fn micro_processor() {
  function head_phone (line 151) | fn head_phone() {
  function micro_services (line 158) | fn micro_services() {
  function dash_board (line 165) | fn dash_board() {
  function site_map (line 172) | fn site_map() {
  function fire_wall (line 179) | fn fire_wall() {
  function bit_stream (line 186) | fn bit_stream() {
  function block_chain (line 193) | fn block_chain() {
  function thumb_nail (line 200) | fn thumb_nail() {
  function bath_room (line 207) | fn bath_room() {
  function every_one (line 215) | fn every_one() {
  function play_ground (line 222) | fn play_ground() {
  function run_way (line 229) | fn run_way() {
  function cyber_space (line 236) | fn cyber_space() {
  function cyber_attack (line 243) | fn cyber_attack() {
  function web_socket (line 250) | fn web_socket() {
  function finger_print (line 257) | fn finger_print() {
  function got_is_not_possessive (line 264) | fn got_is_not_possessive() {
  function allow_issue_662 (line 269) | fn allow_issue_662() {
  function allow_issue_661 (line 278) | fn allow_issue_661() {
  function allow_issue_704 (line 283) | fn allow_issue_704() {
  function allows_issue_721 (line 292) | fn allows_issue_721() {
  function allows_678 (line 301) | fn allows_678() {
  function ina_not_suggested (line 310) | fn ina_not_suggested() {
  function allow_suppress_or (line 319) | fn allow_suppress_or() {
  function allow_an_arm_and_a_leg (line 328) | fn allow_an_arm_and_a_leg() {
  function allow_well_and_723 (line 337) | fn allow_well_and_723() {
  function allow_can_not (line 346) | fn allow_can_not() {
  function dont_flag_lot_to (line 351) | fn dont_flag_lot_to() {
  function dont_flag_to_me (line 360) | fn dont_flag_to_me() {
  function allow_issue_1553 (line 369) | fn allow_issue_1553() {
  function allow_issue_1496 (line 377) | fn allow_issue_1496() {
  function allow_issue_1298 (line 385) | fn allow_issue_1298() {
  function dont_flag_project_or (line 393) | fn dont_flag_project_or() {

FILE: harper-core/src/linting/compound_subject_i.rs
  constant POSSESSIVE_DETERMINERS (line 8) | const POSSESSIVE_DETERMINERS: &[&str] = &["my", "your", "her", "his", "t...
  type CompoundSubjectI (line 10) | pub struct CompoundSubjectI {
  method default (line 15) | fn default() -> Self {
  type Unit (line 42) | type Unit = Chunk;
  method expr (line 44) | fn expr(&self) -> &dyn Expr {
  method match_to_lint (line 48) | fn match_to_lint(&self, matched_tokens: &[Token], source: &[char]) -> Op...
  method description (line 65) | fn description(&self) -> &'static str {
  function corrects_my_mother_and_me (line 76) | fn corrects_my_mother_and_me() {
  function corrects_my_brother_and_me (line 85) | fn corrects_my_brother_and_me() {
  function corrects_your_friend_and_me (line 94) | fn corrects_your_friend_and_me() {
  function corrects_her_manager_and_me (line 103) | fn corrects_her_manager_and_me() {
  function corrects_his_cat_and_me (line 112) | fn corrects_his_cat_and_me() {
  function corrects_their_kids_and_me (line 121) | fn corrects_their_kids_and_me() {
  function corrects_our_neighbor_and_me (line 130) | fn corrects_our_neighbor_and_me() {
  function corrects_with_quote_prefix (line 139) | fn corrects_with_quote_prefix() {
  function corrects_all_caps (line 148) | fn corrects_all_caps() {
  function ignores_between_you_and_me (line 157) | fn ignores_between_you_and_me() {
  function ignores_comma_after_me (line 166) | fn ignores_comma_after_me() {

FILE: harper-core/src/linting/confident.rs
  type Confident (line 9) | pub struct Confident {
  method default (line 14) | fn default() -> Self {
  type Unit (line 29) | type Unit = Chunk;
  method expr (line 31) | fn expr(&self) -> &dyn Expr {
  method match_to_lint (line 35) | fn match_to_lint(&self, matched_tokens: &[Token], _source: &[char]) -> O...
  method description (line 47) | fn description(&self) -> &'static str {
  function describing_person_incorrect (line 58) | fn describing_person_incorrect() {
  function describing_person_correct (line 67) | fn describing_person_correct() {
  function certainty_incorrect (line 76) | fn certainty_incorrect() {
  function certainty_correct (line 85) | fn certainty_correct() {
  function demeanor_incorrect (line 94) | fn demeanor_incorrect() {
  function demeanor_correct (line 103) | fn demeanor_correct() {
  function professional_incorrect (line 112) | fn professional_incorrect() {
  function professional_correct (line 121) | fn professional_correct() {
  function assured_tone_incorrect (line 130) | fn assured_tone_incorrect() {
  function assured_tone_correct (line 139) | fn assured_tone_correct() {
  function extra_text_between (line 148) | fn extra_text_between() {
  function linking_verb_was_confidant (line 157) | fn linking_verb_was_confidant() {

FILE: harper-core/src/linting/correct_number_suffix.rs
  type CorrectNumberSuffix (line 7) | pub struct CorrectNumberSuffix;
  method lint (line 10) | fn lint(&mut self, document: &Document) -> Vec<Lint> {
  method description (line 39) | fn description(&self) -> &'static str {
  function passes_correct_cases (line 50) | fn passes_correct_cases() {
  function detects_incorrect_cases (line 57) | fn detects_incorrect_cases() {

FILE: harper-core/src/linting/criteria_phenomena.rs
  type CriteriaPhenomena (line 11) | pub struct CriteriaPhenomena {
    method new (line 18) | fn new() -> Self {
  type Unit (line 34) | type Unit = Chunk;
  method expr (line 36) | fn expr(&self) -> &dyn Expr {
  method match_to_lint (line 40) | fn match_to_lint(&self, matched_tokens: &[Token], source: &[char]) -> Op...
  method description (line 64) | fn description(&self) -> &'static str {
  method default (line 70) | fn default() -> Self {
  function can_detect_incorrect_criteria (line 81) | fn can_detect_incorrect_criteria() {
  function can_detect_incorrect_phenomena (line 90) | fn can_detect_incorrect_phenomena() {
  function allows_correct_criteria (line 99) | fn allows_correct_criteria() {
  function allows_correct_phenomena (line 108) | fn allows_correct_phenomena() {

FILE: harper-core/src/linting/cure_for.rs
  type CureFor (line 9) | pub struct CureFor {
  method default (line 14) | fn default() -> Self {
  type Unit (line 24) | type Unit = Chunk;
  method expr (line 26) | fn expr(&self) -> &dyn Expr {
  method match_to_lint (line 30) | fn match_to_lint(&self, matched_tokens: &[Token], source: &[char]) -> Op...
  method description (line 45) | fn description(&self) -> &str {
  function corrects_simple_cure_against (line 56) | fn corrects_simple_cure_against() {
  function corrects_plural_cures_against (line 65) | fn corrects_plural_cures_against() {
  function corrects_past_participle_cured_against (line 74) | fn corrects_past_participle_cured_against() {
  function corrects_uppercase_against (line 83) | fn corrects_uppercase_against() {
  function corrects_at_sentence_start (line 92) | fn corrects_at_sentence_start() {
  function does_not_flag_cure_for (line 101) | fn does_not_flag_cure_for() {
  function does_not_flag_cure_from (line 110) | fn does_not_flag_cure_from() {
  function does_not_flag_with_comma (line 119) | fn does_not_flag_with_comma() {
  function does_not_flag_unrelated_against (line 128) | fn does_not_flag_unrelated_against() {
  function does_not_flag_secure_against (line 137) | fn does_not_flag_secure_against() {

FILE: harper-core/src/linting/currency_placement.rs
  type CurrencyPlacement (line 8) | pub struct CurrencyPlacement {}
  method lint (line 11) | fn lint(&mut self, document: &Document) -> Vec<Lint> {
  method description (line 33) | fn description(&self) -> &str {
  function generate_lint_for_tokens (line 39) | fn generate_lint_for_tokens(a: &Token, b: &Token, document: &Document) -...
  function eof (line 72) | fn eof() {
  function blog_title_allows_correct (line 81) | fn blog_title_allows_correct() {
  function blog_title (line 86) | fn blog_title() {
  function blog_title_cents (line 95) | fn blog_title_cents() {
  function blog_title_with_space (line 104) | fn blog_title_with_space() {
  function multiple_dollar_markdown (line 113) | fn multiple_dollar_markdown() {
  function multiple_dollar_plain_english (line 122) | fn multiple_dollar_plain_english() {
  function multiple_pound (line 131) | fn multiple_pound() {
  function suffix (line 140) | fn suffix() {
  function seven_even_two_decimal_clean (line 149) | fn seven_even_two_decimal_clean() {

FILE: harper-core/src/linting/damages.rs
  type Damages (line 22) | pub struct Damages {
  method default (line 27) | fn default() -> Self {
  type Unit (line 35) | type Unit = Sentence;
  method expr (line 37) | fn expr(&self) -> &dyn Expr {
  method match_to_lint_with_context (line 41) | fn match_to_lint_with_context(
  method description (line 162) | fn description(&self) -> &str {
  function fix_robust_against_damages_by_prev_preposition (line 175) | fn fix_robust_against_damages_by_prev_preposition() {
  function fix_vehicle_damages_on_a_car_by_fall_through (line 184) | fn fix_vehicle_damages_on_a_car_by_fall_through() {
  function fix_damages_on_mangoes (line 193) | fn fix_damages_on_mangoes() {
  function fix_types_of_damages_of_roads (line 202) | fn fix_types_of_damages_of_roads() {
  function ignore_damages_in_lost_chance_cases (line 214) | fn ignore_damages_in_lost_chance_cases() {
  function ignore_claim_for_damages (line 222) | fn ignore_claim_for_damages() {
  function ignore_pay_damages (line 230) | fn ignore_pay_damages() {
  function ignore_damages_them (line 244) | fn ignore_damages_them() {
  function ignore_damages_firefox (line 252) | fn ignore_damages_firefox() {
  function ignore_damages_underlaying_windows (line 260) | fn ignore_damages_underlaying_windows() {
  function ignore_estimate_the_damages_and_the_damages_result (line 271) | fn ignore_estimate_the_damages_and_the_damages_result() {
  function ignore_damages_inference (line 281) | fn ignore_damages_inference() {
  function ignore_received_errors (line 290) | fn ignore_received_errors() {
  function ignore_asset_level_damages (line 299) | fn ignore_asset_level_damages() {

FILE: harper-core/src/linting/dashes.rs
  constant EN_DASH (line 9) | const EN_DASH: char = '–';
  constant EM_DASH (line 10) | const EM_DASH: char = '—';
  type Dashes (line 12) | pub struct Dashes {
  method default (line 17) | fn default() -> Self {
  type Unit (line 31) | type Unit = Chunk;
  method expr (line 33) | fn expr(&self) -> &dyn Expr {
  method match_to_lint (line 37) | fn match_to_lint(&self, matched_tokens: &[Token], _source: &[char]) -> O...
  method description (line 61) | fn description(&self) -> &'static str {
  function catches_en_dash (line 74) | fn catches_en_dash() {
  function catches_em_dash (line 83) | fn catches_em_dash() {
  function no_overlaps (line 92) | fn no_overlaps() {
  function no_lint_for_long_hyphen_sequences (line 97) | fn no_lint_for_long_hyphen_sequences() {

FILE: harper-core/src/linting/day_and_age.rs
  type DayAndAge (line 7) | pub struct DayAndAge {
  method default (line 12) | fn default() -> Self {
  type Unit (line 26) | type Unit = Chunk;
  method description (line 28) | fn description(&self) -> &str {
  method expr (line 32) | fn expr(&self) -> &dyn Expr {
  method match_to_lint_with_context (line 36) | fn match_to_lint_with_context(
  function allow_in_this_day_and_age (line 125) | fn allow_in_this_day_and_age() {
  function for_this_day_and_age_seems_to_be_acceptable (line 133) | fn for_this_day_and_age_seems_to_be_acceptable() {
  function at_this_day_and_age (line 143) | fn at_this_day_and_age() {
  function by_this_day_in_age (line 152) | fn by_this_day_in_age() {
  function in_these_day_and_age (line 161) | fn in_these_day_and_age() {
  function in_these_days_and_age (line 170) | fn in_these_days_and_age() {
  function in_these_days_in_age (line 179) | fn in_these_days_in_age() {
  function in_this_day_an_age (line 188) | fn in_this_day_an_age() {
  function in_this_day_and_ages (line 197) | fn in_this_day_and_ages() {
  function in_this_day_in_age (line 206) | fn in_this_day_in_age() {
  function in_this_days_and_age (line 215) | fn in_this_days_and_age() {
  function is_this_day_and_age_typo (line 224) | fn is_this_day_and_age_typo() {
  function it_this_day_and_age_typo (line 233) | fn it_this_day_and_age_typo() {
  function of_this_day_and_age (line 242) | fn of_this_day_and_age() {
  function to_this_day_and_age (line 251) | fn to_this_day_and_age() {
  function no_prep_this_day_in_age (line 260) | fn no_prep_this_day_in_age() {
  function no_prep_these_days_and_ages (line 269) | fn no_prep_these_days_and_ages() {
  function since_is_a_preposition_but_also_a_conjunction (line 278) | fn since_is_a_preposition_but_also_a_conjunction() {

FILE: harper-core/src/linting/despite_it_is.rs
  type DespiteItIs (line 21) | pub struct DespiteItIs {
  method default (line 26) | fn default() -> Self {
  type Unit (line 41) | type Unit = Chunk;
  method description (line 43) | fn description(&self) -> &'static str {
  method expr (line 47) | fn expr(&self) -> &dyn Expr {
  method match_to_lint_with_context (line 51) | fn match_to_lint_with_context(
  function despite_i_am (line 141) | fn despite_i_am() {
  function despite_it_is_available (line 154) | fn despite_it_is_available() {
  function despite_it_is_detected (line 168) | fn despite_it_is_detected() {
  function despite_i_am_in (line 182) | fn despite_i_am_in() {
  function despite_it_was_not (line 196) | fn despite_it_was_not() {
  function despite_we_are_using (line 210) | fn despite_we_are_using() {
  function despite_they_are_already (line 223) | fn despite_they_are_already() {
  function despite_it_was_removed (line 236) | fn despite_it_was_removed() {
  function ignore_despite_they_shouldnt (line 253) | fn ignore_despite_they_shouldnt() {
  function ignore_despite_i_was_playing (line 261) | fn ignore_despite_i_was_playing() {
  function ignore_despite_they_were_valid (line 274) | fn ignore_despite_they_were_valid() {

FILE: harper-core/src/linting/despite_of.rs
  type DespiteOf (line 8) | pub struct DespiteOf {
  method default (line 13) | fn default() -> Self {
  type Unit (line 23) | type Unit = Chunk;
  method expr (line 25) | fn expr(&self) -> &dyn Expr {
  method match_to_lint (line 29) | fn match_to_lint(&self, matched: &[Token], source: &[char]) -> Option<Li...
  method description (line 45) | fn description(&self) -> &'static str {
  function catches_lowercase (line 56) | fn catches_lowercase() {
  function catches_different_cases (line 65) | fn catches_different_cases() {
  function likes_correction (line 74) | fn likes_correction() {

FILE: harper-core/src/linting/determiner_without_noun.rs
  type DeterminerWithoutNoun (line 8) | pub struct DeterminerWithoutNoun {
  method default (line 13) | fn default() -> Self {
  type Unit (line 24) | type Unit = Chunk;
  method expr (line 26) | fn expr(&self) -> &dyn Expr {
  method match_to_lint (line 30) | fn match_to_lint(&self, matched_tokens: &[Token], _source: &[char]) -> O...
  method description (line 42) | fn description(&self) -> &'static str {
  function flags_determiner_followed_by_conjunction (line 53) | fn flags_determiner_followed_by_conjunction() {
  function flags_indefinite_article_followed_by_conjunction (line 62) | fn flags_indefinite_article_followed_by_conjunction() {
  function allows_correct_use_with_noun (line 68) | fn allows_correct_use_with_noun() {
  function allows_determiner_noun_then_conjunction (line 73) | fn allows_determiner_noun_then_conjunction() {

FILE: harper-core/src/linting/did_past.rs
  type DidPast (line 11) | pub struct DidPast<D> {
  function new (line 20) | pub fn new(dict: D) -> Self {
  function keep_suggestion_if_lemma (line 37) | fn keep_suggestion_if_lemma(&self, suggs: &mut Vec<Vec<char>>, candidate...
  type Unit (line 52) | type Unit = Chunk;
  method description (line 54) | fn description(&self) -> &str {
  method expr (line 58) | fn expr(&self) -> &dyn Expr {
  method match_to_lint (line 62) | fn match_to_lint(&self, toks: &[Token], src: &[char]) -> Option<Lint> {
  function ed_did_forked (line 131) | fn ed_did_forked() {
  function d_did_used (line 142) | fn d_did_used() {
  function y_did_fried (line 153) | fn y_did_fried() {
  function doubed_consonant_logged (line 164) | fn doubed_consonant_logged() {
  function did_past (line 175) | fn did_past() {
  function did_past_with_apostrophe (line 180) | fn did_past_with_apostrophe() {
  function didnt_past_no_apostrophe (line 189) | fn didnt_past_no_apostrophe() {
  function did_i_heard (line 198) | fn did_i_heard() {
  function did_i_heard_with_apostrophe (line 207) | fn did_i_heard_with_apostrophe() {
  function didnt_i_forgot_no_apostrophe (line 216) | fn didnt_i_forgot_no_apostrophe() {
  function ignore_lemma_same_as_past_tense (line 227) | fn ignore_lemma_same_as_past_tense() {
  function fix_did_you_cmae (line 234) | fn fix_did_you_cmae() {
  function fix_did_you_wrote (line 243) | fn fix_did_you_wrote() {
  function fix_didnt_had (line 252) | fn fix_didnt_had() {
  function did_you_went (line 261) | fn did_you_went() {
  function fix_did_needed (line 270) | fn fix_did_needed() {
  function fix_did_thought (line 279) | fn fix_did_thought() {
  function fix_did_wanted (line 288) | fn fix_did_wanted() {
  function fix_did_not_changed (line 297) | fn fix_did_not_changed() {
  function ignore_did_you_read (line 306) | fn ignore_did_you_read() {

FILE: harper-core/src/linting/didnt.rs
  type Didnt (line 6) | pub struct Didnt {
  method default (line 11) | fn default() -> Self {
  type Unit (line 22) | type Unit = Chunk;
  method expr (line 24) | fn expr(&self) -> &dyn Expr {
  method match_to_lint (line 28) | fn match_to_lint(&self, toks: &[Token], src: &[char]) -> Option<Lint> {
  method description (line 43) | fn description(&self) -> &str {
  function corrects_i_dint (line 54) | fn corrects_i_dint() {
  function corrects_you_dint (line 63) | fn corrects_you_dint() {
  function corrects_he_dint (line 72) | fn corrects_he_dint() {
  function corrects_she_dint (line 81) | fn corrects_she_dint() {
  function corrects_we_dint (line 90) | fn corrects_we_dint() {
  function corrects_they_dint (line 99) | fn corrects_they_dint() {
  function corrects_it_dint (line 108) | fn corrects_it_dint() {
  function does_not_flag_dint_noun (line 117) | fn does_not_flag_dint_noun() {
  function does_not_flag_quoted_dint (line 122) | fn does_not_flag_quoted_dint() {
  function does_not_flag_past_tense_with_not (line 127) | fn does_not_flag_past_tense_with_not() {

FILE: harper-core/src/linting/discourse_markers.rs
  type DiscourseMarkers (line 9) | pub struct DiscourseMarkers {
    method new (line 14) | pub fn new() -> Self {
    method lint_sentence (line 60) | fn lint_sentence(&self, sent: &[Token], source: &[char]) -> Option<Lin...
  method default (line 78) | fn default() -> Self {
  method lint (line 84) | fn lint(&mut self, document: &Document) -> Vec<Lint> {
  method description (line 91) | fn description(&self) -> &str {
  function corrects_frankly (line 103) | fn corrects_frankly() {
  function corrects_however (line 112) | fn corrects_however() {
  function corrects_therefore (line 121) | fn corrects_therefore() {
  function corrects_meanwhile (line 130) | fn corrects_meanwhile() {
  function corrects_furthermore (line 139) | fn corrects_furthermore() {
  function corrects_nevertheless (line 148) | fn corrects_nevertheless() {
  function corrects_consequently (line 157) | fn corrects_consequently() {
  function corrects_thus (line 166) | fn corrects_thus() {
  function allows_thus_far (line 175) | fn allows_thus_far() {
  function corrects_instead (line 183) | fn corrects_instead() {
  function corrects_moreover (line 192) | fn corrects_moreover() {
  function corrects_alternatively (line 201) | fn corrects_alternatively() {
  function no_suggestion_if_comma_present (line 210) | fn no_suggestion_if_comma_present() {
  function no_lint_for_mid_sentence_marker (line 218) | fn no_lint_for_mid_sentence_marker() {
  function preserves_whitespace (line 226) | fn preserves_whitespace() {
  function corrects_semicolon_case (line 235) | fn corrects_semicolon_case() {
  function corrects_multiple_sentences (line 244) | fn corrects_multiple_sentences() {
  function allows_single_word_sentence (line 253) | fn allows_single_word_sentence() {
  function corrects_for_example (line 258) | fn corrects_for_example() {
  function no_suggestion_if_comma_after_for_example (line 267) | fn no_suggestion_if_comma_after_for_example() {
  function preserves_whitespace_for_example (line 275) | fn preserves_whitespace_for_example() {
  function corrects_on_the_other_hand (line 284) | fn corrects_on_the_other_hand() {
  function no_lint_for_mid_sentence_on_the_other_hand (line 293) | fn no_lint_for_mid_sentence_on_the_other_hand() {
  function check_2966_is_avoided (line 301) | fn check_2966_is_avoided() {

FILE: harper-core/src/linting/disjoint_prefixes.rs
  type DisjointPrefixes (line 8) | pub struct DisjointPrefixes<D> {
  constant OUT_EXCEPTIONS (line 14) | const OUT_EXCEPTIONS: &[&str] = &["boxes", "facing", "live", "numbers", ...
  constant OVER_EXCEPTIONS (line 15) | const OVER_EXCEPTIONS: &[&str] = &["all", "joy", "long", "night", "readi...
  constant UNDER_EXCEPTIONS (line 16) | const UNDER_EXCEPTIONS: &[&str] = &["development", "mine"];
  constant UP_EXCEPTIONS (line 17) | const UP_EXCEPTIONS: &[&str] = &["loading", "right", "state", "time", "t...
  function new (line 23) | pub fn new(dict: D) -> Self {
  type Unit (line 64) | type Unit = Chunk;
  method expr (line 66) | fn expr(&self) -> &dyn Expr {
  method match_to_lint_with_context (line 70) | fn match_to_lint_with_context(
  method description (line 149) | fn description(&self) -> &str {
  function fix_hyphenated_to_joined (line 163) | fn fix_hyphenated_to_joined() {
  function fix_open_to_joined (line 172) | fn fix_open_to_joined() {
  function dont_join_open_co_op (line 181) | fn dont_join_open_co_op() {
  function dont_join_hyphenated_co_op (line 189) | fn dont_join_hyphenated_co_op() {
  function fix_open_to_hyphenated (line 197) | fn fix_open_to_hyphenated() {

FILE: harper-core/src/linting/do_mistake.rs
  type DoMistake (line 11) | pub struct DoMistake {
  method default (line 16) | fn default() -> Self {
  type Unit (line 45) | type Unit = Chunk;
  method match_to_lint_with_context (line 47) | fn match_to_lint_with_context(
  method description (line 86) | fn description(&self) -> &str {
  method expr (line 90) | fn expr(&self) -> &dyn Expr {
  function did_a_mistake (line 101) | fn did_a_mistake() {
  function did_my_mistakes (line 110) | fn did_my_mistakes() {
  function did_several_mistakes (line 119) | fn did_several_mistakes() {
  function did_some_mistakes (line 128) | fn did_some_mistakes() {
  function did_that_mistake (line 137) | fn did_that_mistake() {
  function did_the_mistake (line 146) | fn did_the_mistake() {
  function did_this_mistake (line 155) | fn did_this_mistake() {
  function do_many_mistakes (line 164) | fn do_many_mistakes() {
  function do_mistake (line 173) | fn do_mistake() {
  function do_some_mistakes (line 182) | fn do_some_mistakes() {
  function do_the_mistake (line 191) | fn do_the_mistake() {
  function do_this_mistake (line 200) | fn do_this_mistake() {
  function do_this_mistakes (line 209) | fn do_this_mistakes() {
  function do_those_mistakes (line 218) | fn do_those_mistakes() {
  function doing_a_mistake (line 227) | fn doing_a_mistake() {
  function doing_several_mistakes (line 236) | fn doing_several_mistakes() {
  function doing_the_mistkae (line 245) | fn doing_the_mistkae() {
  function done_some_mistake (line 254) | fn done_some_mistake() {
  function done_this_mistake (line 263) | fn done_this_mistake() {
  function dont_flag_when_does_a_mistake (line 274) | fn dont_flag_when_does_a_mistake() {
  function dont_flag_did_that_mistake_verb (line 282) | fn dont_flag_did_that_mistake_verb() {
  function dont_flag_does_this_mistake_verb (line 290) | fn dont_flag_does_this_mistake_verb() {
  function dont_flag_does_the_mistake_verb (line 298) | fn dont_flag_does_the_mistake_verb() {

FILE: harper-core/src/linting/dot_initialisms.rs
  type DotInitialisms (line 11) | pub struct DotInitialisms {
  method default (line 17) | fn default() -> Self {
  type Unit (line 40) | type Unit = Chunk;
  method expr (line 42) | fn expr(&self) -> &dyn Expr {
  method match_to_lint (line 46) | fn match_to_lint(&self, matched_tokens: &[Token], source: &[char]) -> Op...
  method description (line 61) | fn description(&self) -> &'static str {
  function matches_eg (line 72) | fn matches_eg() {

FILE: harper-core/src/linting/double_click.rs
  type DoubleClick (line 8) | pub struct DoubleClick {
    method double_click_sequence (line 13) | fn double_click_sequence() -> SequenceExpr {
  method default (line 22) | fn default() -> Self {
  type Unit (line 53) | type Unit = Chunk;
  method expr (line 55) | fn expr(&self) -> &dyn Expr {
  method match_to_lint (line 59) | fn match_to_lint(&self, matched_tokens: &[Token], source: &[char]) -> Op...
  method description (line 84) | fn description(&self) -> &'static str {
  function corrects_basic_command (line 95) | fn corrects_basic_command() {
  function corrects_with_preposition (line 104) | fn corrects_with_preposition() {
  function corrects_with_pronoun (line 113) | fn corrects_with_pronoun() {
  function corrects_plural_form (line 122) | fn corrects_plural_form() {
  function corrects_past_tense (line 131) | fn corrects_past_tense() {
  function corrects_gerund (line 140) | fn corrects_gerund() {
  function corrects_with_caps (line 149) | fn corrects_with_caps() {
  function corrects_multiline (line 158) | fn corrects_multiline() {
  function corrects_at_sentence_end (line 167) | fn corrects_at_sentence_end() {
  function allows_hyphenated_form (line 176) | fn allows_hyphenated_form() {
  function ignores_other_double_words (line 181) | fn ignores_other_double_words() {

FILE: harper-core/src/linting/double_modal.rs
  type DoubleModal (line 10) | pub struct DoubleModal {
  method default (line 15) | fn default() -> Self {
  type Unit (line 25) | type Unit = Chunk;
  method expr (line 27) | fn expr(&self) -> &dyn Expr {
  method match_to_lint (line 31) | fn match_to_lint(&self, matched_tokens: &[Token], source: &[char]) -> Op...
  method description (line 47) | fn description(&self) -> &'static str {
  function detects_might_could (line 58) | fn detects_might_could() {
  function detects_should_ought (line 67) | fn detects_should_ought() {
  function allows_single_modal (line 72) | fn allows_single_modal() {
  function detects_two_double_modals (line 77) | fn detects_two_double_modals() {
  function suggests_removing_second_modal_keeps_first (line 86) | fn suggests_removing_second_modal_keeps_first() {
  function suggests_removing_second_modal_keeps_first_variant_order (line 95) | fn suggests_removing_second_modal_keeps_first_variant_order() {
  function suggests_removing_second_modal_keeps_first_capitalised (line 104) | fn suggests_removing_second_modal_keeps_first_capitalised() {
  function allows_will_need (line 113) | fn allows_will_need() {

FILE: harper-core/src/linting/ellipsis_length.rs
  type EllipsisLength (line 9) | pub struct EllipsisLength;
  method lint (line 12) | fn lint(&mut self, document: &crate::Document) -> Vec<Lint> {
  method description (line 39) | fn description(&self) -> &'static str {
  function allows_correct_ellipsis (line 50) | fn allows_correct_ellipsis() {
  function corrects_long_ellipsis (line 55) | fn corrects_long_ellipsis() {
  function corrects_short_ellipsis (line 61) | fn corrects_short_ellipsis() {

FILE: harper-core/src/linting/else_possessive.rs
  type ElsePossessive (line 11) | pub struct ElsePossessive {
  method default (line 16) | fn default() -> Self {
  type Unit (line 37) | type Unit = Chunk;
  method expr (line 39) | fn expr(&self) -> &dyn Expr {
  method match_to_lint (line 43) | fn match_to_lint(&self, toks: &[Token], _src: &[char]) -> Option<Lint> {
  method description (line 54) | fn description(&self) -> &str {
  function fixes_no_one_elses (line 65) | fn fixes_no_one_elses() {
  function fixes_someone_elses (line 74) | fn fixes_someone_elses() {
  function fixes_anybody_elses (line 83) | fn fixes_anybody_elses() {
  function fixes_everyone_elses (line 92) | fn fixes_everyone_elses() {
  function ignores_correct_form (line 101) | fn ignores_correct_form() {

FILE: harper-core/src/linting/ever_every.rs
  type EverEvery (line 8) | pub struct EverEvery {
  method default (line 13) | fn default() -> Self {
  type Unit (line 34) | type Unit = Chunk;
  method expr (line 36) | fn expr(&self) -> &dyn Expr {
  method match_to_lint (line 40) | fn match_to_lint(&self, toks: &[Token], src: &[char]) -> Option<Lint> {
  method description (line 55) | fn description(&self) -> &str {
  function fix_can_i_every (line 66) | fn fix_can_i_every() {
  function fix_can_they_every (line 75) | fn fix_can_they_every() {
  function fix_can_we_every (line 84) | fn fix_can_we_every() {
  function fix_did_we_every (line 93) | fn fix_did_we_every() {
  function fix_did_you_every (line 102) | fn fix_did_you_every() {
  function fix_do_i_every (line 111) | fn fix_do_i_every() {
  function fix_do_we_every (line 120) | fn fix_do_we_every() {
  function fix_do_you_every (line 129) | fn fix_do_you_every() {
  function fix_dont_i_every (line 138) | fn fix_dont_i_every() {
  function fix_dont_they_every (line 147) | fn fix_dont_they_every() {
  function fix_dont_you_every (line 156) | fn fix_dont_you_every() {
  function fix_have_you_every (line 165) | fn fix_have_you_every() {
  function fix_should_i_every (line 174) | fn fix_should_i_every() {
  function fix_should_we_every (line 183) | fn fix_should_we_every() {
  function fix_should_you_every (line 192) | fn fix_should_you_every() {
  function fix_would_i_every (line 201) | fn fix_would_i_every() {
  function fix_would_they_every (line 210) | fn fix_would_they_every() {
  function dont_flag_should_we_every (line 222) | fn dont_flag_should_we_every() {

FILE: harper-core/src/linting/everyday.rs
  type Everyday (line 9) | pub struct Everyday {
  method default (line 14) | fn default() -> Self {
  type Unit (line 124) | type Unit = Chunk;
  method expr (line 126) | fn expr(&self) -> &dyn Expr {
  method match_to_lint (line 130) | fn match_to_lint(&self, toks: &[Token], src: &[char]) -> Option<Lint> {
  method description (line 185) | fn description(&self) -> &str {
  function dont_flag_lone_adjective (line 196) | fn dont_flag_lone_adjective() {
  function dont_flag_lone_adverb (line 201) | fn dont_flag_lone_adverb() {
  function correct_adjective_at_end_of_chunk (line 206) | fn correct_adjective_at_end_of_chunk() {
  function correct_adverb_after_article_before_noun (line 215) | fn correct_adverb_after_article_before_noun() {
  function correct_adjective_without_following_noun (line 225) | fn correct_adjective_without_following_noun() {
  function dont_flag_everyday_adjective_before_dev (line 234) | fn dont_flag_everyday_adjective_before_dev() {
  function dont_flag_everyday_adjective_before_present_participle (line 243) | fn dont_flag_everyday_adjective_before_present_participle() {
  function dont_flag_everyday_adjective_before_plural_noun (line 248) | fn dont_flag_everyday_adjective_before_plural_noun() {
  function correct_everyday_at_end_of_sentence_after_past_verb (line 257) | fn correct_everyday_at_end_of_sentence_after_past_verb() {
  function dont_flag_every_day_at_start_of_sentence_before_comma (line 266) | fn dont_flag_every_day_at_start_of_sentence_before_comma() {
  function dont_flag_every_day_at_start_of_sentence_before_copula (line 275) | fn dont_flag_every_day_at_start_of_sentence_before_copula() {
  function dont_flag_every_day_at_end_of_sentence_after_noun (line 280) | fn dont_flag_every_day_at_end_of_sentence_after_noun() {
  function dont_flag_every_day_after_noun_before_conjunction (line 285) | fn dont_flag_every_day_after_noun_before_conjunction() {
  function correct_every_day_after_article (line 295) | fn correct_every_day_after_article() {
  function dont_flag_everyday_before_unknown_word (line 304) | fn dont_flag_everyday_before_unknown_word() {
  function dont_flag_every_day_at_end_of_chunk_after_adverb (line 313) | fn dont_flag_every_day_at_end_of_chunk_after_adverb() {
  function dont_flag_every_day_after_verb_before_if (line 322) | fn dont_flag_every_day_after_verb_before_if() {
  function dont_flag_every_day_after_noun_before_preposition (line 331) | fn dont_flag_every_day_after_noun_before_preposition() {
  function dont_flag_every_day_after_time (line 340) | fn dont_flag_every_day_after_time() {
  function dont_flag_every_day_at_start_of_chunk_before_np (line 349) | fn dont_flag_every_day_at_start_of_chunk_before_np() {
  function fix_everyday_and_every_day_used_wrongly (line 358) | fn fix_everyday_and_every_day_used_wrongly() {
  function fix_reddit_why_does_everyday (line 367) | fn fix_reddit_why_does_everyday() {
  function fix_reddit_everyday_is_going_to (line 376) | fn fix_reddit_everyday_is_going_to() {
  function fix_reddit_draw_everyday (line 385) | fn fix_reddit_draw_everyday() {
  function fix_reddit_two_bad_out_of_three (line 394) | fn fix_reddit_two_bad_out_of_three() {
  function fix_reddit_every_day_routine (line 403) | fn fix_reddit_every_day_routine() {
  function fix_stackoverflow_every_day_things (line 412) | fn fix_stackoverflow_every_day_things() {
  function fix_reddit_everyday_is_same (line 421) | fn fix_reddit_everyday_is_same() {
  function fix_medium_little_bit_everyday (line 431) | fn fix_medium_little_bit_everyday() {
  function fix_stackexchange_use_everyday (line 440) | fn fix_stackexchange_use_everyday() {
  function fix_github_what_i_learned_everyday (line 449) | fn fix_github_what_i_learned_everyday() {
  function fix_medium_one_bad_out_of_three (line 458) | fn fix_medium_one_bad_out_of_three() {
  function fix_medium_doing_something_everyday (line 467) | fn fix_medium_doing_something_everyday() {
  function fix_medium_all_caps (line 476) | fn fix_medium_all_caps() {
  function dont_flag_every_day_singular_noun_2020 (line 485) | fn dont_flag_every_day_singular_noun_2020() {

FILE: harper-core/src/linting/expand_memory_shorthands.rs
  type ExpandMemoryShorthands (line 10) | pub struct ExpandMemoryShorthands {
    method new (line 15) | pub fn new() -> Self {
    method get_replacement (line 29) | fn get_replacement(abbreviation: &str, plural: Option<bool>) -> Option...
  method default (line 64) | fn default() -> Self {
  type Unit (line 70) | type Unit = Chunk;
  method expr (line 72) | fn expr(&self) -> &dyn Expr {
  method match_to_lint (line 76) | fn match_to_lint(&self, matched_tokens: &[Token], source: &[char]) -> Op...
  method description (line 107) | fn description(&self) -> &str {
  function detects_bytes (line 119) | fn detects_bytes() {
  function detects_kilobytes (line 124) | fn detects_kilobytes() {
  function detects_megabytes (line 129) | fn detects_megabytes() {
  function detects_gigabytes (line 134) | fn detects_gigabytes() {
  function detects_terabytes (line 139) | fn detects_terabytes() {
  function detects_kibibytes (line 144) | fn detects_kibibytes() {
  function detects_mebibytes (line 149) | fn detects_mebibytes() {
  function detects_gibibytes (line 154) | fn detects_gibibytes() {
  function detects_tebibytes (line 159) | fn detects_tebibytes() {
  function detects_petabytes (line 164) | fn detects_petabytes() {
  function detects_exabytes (line 169) | fn detects_exabytes() {
  function detects_zettabytes (line 174) | fn detects_zettabytes() {
  function detects_yottabytes (line 179) | fn detects_yottabytes() {
  function detects_quettabytes (line 184) | fn detects_quettabytes() {
  function detects_pebibytes (line 189) | fn detects_pebibytes() {
  function detects_exbibytes (line 194) | fn detects_exbibytes() {
  function detects_zebibytes (line 199) | fn detects_zebibytes() {
  function detects_yobibytes (line 204) | fn detects_yobibytes() {
  function detects_robibytes (line 209) | fn detects_robibytes() {
  function detects_quebibytes (line 214) | fn detects_quebibytes() {
  function handles_punctuation (line 219) | fn handles_punctuation() {
  function handles_adjacent_number (line 224) | fn handles_adjacent_number() {
  function handles_hyphen_separated (line 229) | fn handles_hyphen_separated() {
  function doesnt_handle_wrong_kb_cases (line 234) | fn doesnt_handle_wrong_kb_cases() {

FILE: harper-core/src/linting/expand_time_shorthands.rs
  type ExpandTimeShorthands (line 11) | pub struct ExpandTimeShorthands {
    method new (line 16) | pub fn new() -> Self {
    method get_replacement (line 29) | fn get_replacement(abbreviation: &str, plural: Option<bool>) -> Option...
  method default (line 46) | fn default() -> Self {
  type Unit (line 52) | type Unit = Chunk;
  method expr (line 54) | fn expr(&self) -> &dyn Expr {
  method match_to_lint (line 58) | fn match_to_lint(&self, matched_tokens: &[Token], source: &[char]) -> Op...
  method description (line 89) | fn description(&self) -> &str {
  function detects_singular_hour (line 101) | fn detects_singular_hour() {
  function detects_singular_minute (line 106) | fn detects_singular_minute() {
  function detects_singular_second (line 111) | fn detects_singular_second() {
  function detects_plural_hours (line 116) | fn detects_plural_hours() {
  function detects_plural_minutes (line 121) | fn detects_plural_minutes() {
  function detects_plural_seconds (line 126) | fn detects_plural_seconds() {
  function detects_millisecond (line 131) | fn detects_millisecond() {
  function detects_milliseconds (line 136) | fn detects_milliseconds() {
  function handles_punctuation_hour (line 141) | fn handles_punctuation_hour() {
  function handles_punctuation_minute (line 146) | fn handles_punctuation_minute() {
  function handles_punctuation_second (line 151) | fn handles_punctuation_second() {
  function handles_adjacent_number_hour (line 156) | fn handles_adjacent_number_hour() {
  function handles_adjacent_number_minute (line 161) | fn handles_adjacent_number_minute() {
  function handles_adjacent_number_second (line 166) | fn handles_adjacent_number_second() {

FILE: harper-core/src/linting/expr_linter.rs
  type DocumentIterator (line 8) | pub trait DocumentIterator {
    method iter_units (line 11) | fn iter_units<'a>(document: &'a Document) -> Box<dyn Iterator<Item = &...
    type Unit (line 20) | type Unit = Chunk;
    method iter_units (line 22) | fn iter_units<'a>(document: &'a Document) -> Box<dyn Iterator<Item = &...
    type Unit (line 28) | type Unit = Sentence;
    method iter_units (line 30) | fn iter_units<'a>(document: &'a Document) -> Box<dyn Iterator<Item = &...
  type Chunk (line 15) | pub struct Chunk;
  type Sentence (line 17) | pub struct Sentence;
  type ExprLinter (line 40) | pub trait ExprLinter: LSend {
    method expr (line 44) | fn expr(&self) -> &dyn Expr;
    method match_to_lint (line 54) | fn match_to_lint(&self, matched_tokens: &[Token], source: &[char]) -> ...
    method match_to_lint_with_context (line 64) | fn match_to_lint_with_context(
    method description (line 75) | fn description(&self) -> &str;
    type Unit (line 196) | type Unit = Chunk;
    method expr (line 198) | fn expr(&self) -> &dyn Expr {
    method match_to_lint (line 202) | fn match_to_lint(&self, toks: &[Token], _src: &[char]) -> Option<Lint> {
    method description (line 211) | fn description(&self) -> &str {
    type Unit (line 229) | type Unit = Chunk;
    method expr (line 231) | fn expr(&self) -> &dyn Expr {
    method match_to_lint_with_context (line 235) | fn match_to_lint_with_context(
    method description (line 277) | fn description(&self) -> &str {
    type Unit (line 295) | type Unit = Sentence;
    method expr (line 297) | fn expr(&self) -> &dyn Expr {
    method match_to_lint (line 301) | fn match_to_lint(&self, toks: &[Token], _src: &[char]) -> Option<Lint> {
    method description (line 310) | fn description(&self) -> &str {
  function find_the_only_token_matching (line 82) | pub fn find_the_only_token_matching<'a, F>(
  method lint (line 102) | fn lint(&mut self, document: &Document) -> Vec<Lint> {
  method description (line 113) | fn description(&self) -> &str {
  function run_on_chunk (line 118) | pub fn run_on_chunk<'a>(
  function followed_by_word (line 142) | pub fn followed_by_word(
  function followed_by_hyphen (line 155) | pub fn followed_by_hyphen(context: Option<(&[Token], &[Token])>) -> bool {
  function preceded_by_word (line 161) | pub fn preceded_by_word(
  type TestSimpleLinter (line 183) | pub struct TestSimpleLinter {
  method default (line 188) | fn default() -> Self {
  type TestContextLinter (line 216) | pub struct TestContextLinter {
  method default (line 221) | fn default() -> Self {
  type TestSentenceLinter (line 282) | pub struct TestSentenceLinter {
  method default (line 287) | fn default() -> Self {
  function simple_test_123 (line 316) | fn simple_test_123() {
  function context_test_123 (line 321) | fn context_test_123() {
  function context_test_321 (line 326) | fn context_test_321() {
  function sentence_test_123 (line 331) | fn sentence_test_123() {

FILE: harper-core/src/linting/far_be_it.rs
  type FarBeIt (line 7) | pub struct FarBeIt {
  method default (line 12) | fn default() -> Self {
  type Unit (line 27) | type Unit = Chunk;
  method expr (line 29) | fn expr(&self) -> &dyn Expr {
  method match_to_lint (line 33) | fn match_to_lint(&self, toks: &[Token], src: &[char]) -> Option<Lint> {
  method description (line 59) | fn description(&self) -> &'static str {
  function far_be_it_for_me_capitalized (line 72) | fn far_be_it_for_me_capitalized() {
  function far_be_it_for_me_lowercase (line 81) | fn far_be_it_for_me_lowercase() {
  function far_be_it_that (line 90) | fn far_be_it_that() {
  function far_be_it_for_the_software (line 99) | fn far_be_it_for_the_software() {
  function missing_punctuation_false_positive (line 109) | fn missing_punctuation_false_positive() {
  function far_be_it_to (line 117) | fn far_be_it_to() {

FILE: harper-core/src/linting/fascinated_by.rs
  type FascinatedBy (line 7) | pub struct FascinatedBy {
  method default (line 12) | fn default() -> Self {
  type Unit (line 20) | type Unit = Chunk;
  method expr (line 22) | fn expr(&self) -> &dyn Expr {
  method match_to_lint (line 26) | fn match_to_lint(&self, toks: &[Token], src: &[char]) -> Option<Lint> {
  method description (line 46) | fn description(&self) -> &str {
  function fix_amiga (line 56) | fn fix_amiga() {
  function fix_microbit (line 69) | fn fix_microbit() {
  function fix_software_development (line 82) | fn fix_software_development() {
  function fix_computer_science (line 95) | fn fix_computer_science() {
  function fix_possibilities (line 108) | fn fix_possibilities() {
  function fix_project (line 121) | fn fix_project() {
  function fix_work (line 134) | fn fix_work() {
  function fix_ais (line 147) | fn fix_ais() {
  function fix_innovative_ideas (line 160) | fn fix_innovative_ideas() {
  function fix_coding (line 173) | fn fix_coding() {

FILE: harper-core/src/linting/fed_up_with.rs
  type FedUpWith (line 7) | pub struct FedUpWith {
    method new (line 13) | pub fn new(dialect: Dialect) -> Self {
  type Unit (line 21) | type Unit = Chunk;
  method expr (line 23) | fn expr(&self) -> &dyn Expr {
  method match_to_lint (line 27) | fn match_to_lint(&self, toks: &[Token], src: &[char]) -> Option<Lint> {
  method description (line 47) | fn description(&self) -> &str {
  function correct_fed_up_of_in_us_english (line 59) | fn correct_fed_up_of_in_us_english() {
  function correct_fed_up_of_in_canadian_english (line 68) | fn correct_fed_up_of_in_canadian_english() {
  function correct_fed_up_of_in_aus_english (line 77) | fn correct_fed_up_of_in_aus_english() {
  function correct_fed_up_of_in_indian_english (line 86) | fn correct_fed_up_of_in_indian_english() {
  function dont_flag_fed_up_of_in_british_english (line 95) | fn dont_flag_fed_up_of_in_british_english() {

FILE: harper-core/src/linting/feel_fell.rs
  type FeelFell (line 8) | pub struct FeelFell {
  method default (line 13) | fn default() -> Self {
  type Unit (line 42) | type Unit = Chunk;
  method expr (line 44) | fn expr(&self) -> &dyn Expr {
  method match_to_lint (line 48) | fn match_to_lint(&self, toks: &[Token], src: &[char]) -> Option<Lint> {
  method description (line 67) | fn description(&self) -> &'static str {
  function fix_i_fell_like (line 79) | fn fix_i_fell_like() {
  function fix_if_you_fell_like_it (line 88) | fn fix_if_you_fell_like_it() {
  function fix_i_dont_fell_like (line 97) | fn fix_i_dont_fell_like() {
  function fix_fell_comfortable (line 106) | fn fix_fell_comfortable() {
  function fix_fell_good (line 115) | fn fix_fell_good() {
  function fix_didnt_fell (line 124) | fn fix_didnt_fell() {
  function fix_fell_free (line 133) | fn fix_fell_free() {
  function fix_fell_right (line 143) | fn fix_fell_right() {
  function dont_flag_fell_right_into (line 152) | fn dont_flag_fell_right_into() {
  function dont_flag_fell_right_through (line 160) | fn dont_flag_fell_right_through() {
  function fix_does_not_fell_comfortable (line 168) | fn fix_does_not_fell_comfortable() {
  function dont_flag_didnt_fell_for_it (line 178) | fn dont_flag_didnt_fell_for_it() {
  function fix_fell_that (line 186) | fn fix_fell_that() {
  function fix_fell_it (line 195) | fn fix_fell_it() {
  function fix_fell_its (line 204) | fn fix_fell_its() {
  function fix_fell_im (line 213) | fn fix_fell_im() {
  function fix_fell_we (line 222) | fn fix_fell_we() {
  function fix_fell_i (line 231) | fn fix_fell_i() {
  function fix_fell_you (line 240) | fn fix_fell_you() {

FILE: harper-core/src/linting/few_units_of_time_ago.rs
  type FewUnitsOfTimeAgo (line 10) | pub struct FewUnitsOfTimeAgo {
  method default (line 15) | fn default() -> Self {
  type Unit (line 32) | type Unit = Chunk;
  method expr (line 34) | fn expr(&self) -> &dyn Expr {
  method match_to_lint (line 38) | fn match_to_lint(&self, toks: &[Token], src: &[char]) -> Option<Lint> {
  method description (line 62) | fn description(&self) -> &'static str {
  function fix_few_minutes_ago (line 76) | fn fix_few_minutes_ago() {
  function dont_flag_a_few_minutes_ago (line 85) | fn dont_flag_a_few_minutes_ago() {
  function fix_done_few_minutes_ago (line 90) | fn fix_done_few_minutes_ago() {
  function dont_flag_done_a_few_minutes_ago (line 99) | fn dont_flag_done_a_few_minutes_ago() {
  function fix_after_space (line 105) | fn fix_after_space() {
  function fix_2nd_sentence (line 115) | fn fix_2nd_sentence() {
  function fix_days (line 126) | fn fix_days() {
  function fix_decades (line 135) | fn fix_decades() {
  function fix_hours (line 144) | fn fix_hours() {
  function fix_minutes (line 153) | fn fix_minutes() {
  function fix_months (line 162) | fn fix_months() {
  function fix_ms (line 171) | fn fix_ms() {
  function fix_seconds (line 180) | fn fix_seconds() {
  function fix_weekends (line 189) | fn fix_weekends() {
  function fix_weeks (line 198) | fn fix_weeks() {
  function fix_years (line 207) | fn fix_years() {
  function dont_flag_centuries (line 218) | fn dont_flag_centuries() {
  function dont_flag_days (line 227) | fn dont_flag_days() {
  function dont_flag_decades (line 236) | fn dont_flag_decades() {
  function dont_flag_hours (line 245) | fn dont_flag_hours() {
  function dont_flag_milliseconds (line 254) | fn dont_flag_milliseconds() {
  function dont_flag_minutes (line 263) | fn dont_flag_minutes() {
  function dont_flag_moments (line 272) | fn dont_flag_moments() {
  function dont_flag_months (line 281) | fn dont_flag_months() {
  function dont_flag_nights (line 290) | fn dont_flag_nights() {
  function dont_flag_seconds (line 299) | fn dont_flag_seconds() {
  function dont_flag_weeks (line 308) | fn dont_flag_weeks() {
  function dont_flag_years (line 317) | fn dont_flag_years() {
  function dont_flag_decade (line 328) | fn dont_flag_decade() {
  function dont_flag_hour (line 337) | fn dont_flag_hour() {
  function dont_flag_millennia (line 346) | fn dont_flag_millennia() {
  function dont_flag_minute (line 355) | fn dont_flag_minute() {
  function dont_flag_moment (line 364) | fn dont_flag_moment() {
  function dont_flag_month (line 373) | fn dont_flag_month() {
  function dont_flag_second (line 382) | fn dont_flag_second() {
  function dont_flag_week (line 391) | fn dont_flag_week() {
  function dont_flag_year (line 400) | fn dont_flag_year() {
  function dont_flag_days_apos (line 411) | fn dont_flag_days_apos() {
  function dont_flag_months_apos (line 420) | fn dont_flag_months_apos() {
  function dont_flag_weeks_apos (line 429) | fn dont_flag_weeks_apos() {
  function dont_flag_years_apos (line 438) | fn dont_flag_years_apos() {
  function fix_day (line 449) | fn fix_day() {
  function fix_decade (line 459) | fn fix_decade() {
  function fix_minute (line 468) | fn fix_minute() {
  function fix_weekend (line 477) | fn fix_weekend() {

FILE: harper-core/src/linting/filler_words.rs
  type FillerWords (line 9) | pub struct FillerWords {
  method default (line 15) | fn default() -> Self {
  type Unit (line 28) | type Unit = Chunk;
  method expr (line 30) | fn expr(&self) -> &dyn Expr {
  method match_to_lint (line 34) | fn match_to_lint(&self, toks: &[Token], _src: &[char]) -> Option<Lint> {
  method description (line 45) | fn description(&self) -> &str {
  function remove_uh (line 56) | fn remove_uh() {
  function remove_um_st_start (line 65) | fn remove_um_st_start() {

FILE: harper-core/src/linting/find_fine.rs
  type FindFine (line 9) | pub struct FindFine {
  method default (line 14) | fn default() -> Self {
  type Unit (line 24) | type Unit = Chunk;
  method expr (line 26) | fn expr(&self) -> &dyn Expr {
  method match_to_lint (line 30) | fn match_to_lint(&self, matched_tokens: &[Token], source: &[char]) -> Op...
  method description (line 45) | fn description(&self) -> &'static str {
  function issue_2115 (line 57) | fn issue_2115() {

FILE: harper-core/src/linting/first_aid_kit.rs
  type FirstAidKit (line 10) | pub struct FirstAidKit {
  method default (line 15) | fn default() -> Self {
  type Unit (line 25) | type Unit = Chunk;
  method expr (line 27) | fn expr(&self) -> &dyn Expr {
  method match_to_lint (line 31) | fn match_to_lint(&self, tokens: &[Token], source: &[char]) -> Option<Lin...
  method description (line 47) | fn description(&self) -> &str {
  function corrects_first_aid_kid (line 58) | fn corrects_first_aid_kid() {
  function corrects_starter_kid (line 67) | fn corrects_starter_kid() {
  function corrects_travel_kid (line 76) | fn corrects_travel_kid() {
  function corrects_tool_kid (line 85) | fn corrects_tool_kid() {
  function does_not_flag_kid_in_other_contexts (line 94) | fn does_not_flag_kid_in_other_contexts() {

FILE: harper-core/src/linting/flesh_out_vs_full_fledged.rs
  type FleshOutVsFullFledged (line 7) | pub struct FleshOutVsFullFledged {
  method default (line 12) | fn default() -> Self {
  type Unit (line 26) | type Unit = Chunk;
  method expr (line 28) | fn expr(&self) -> &dyn Expr {
  method match_to_lint_with_context (line 32) | fn match_to_lint_with_context(
  method description (line 179) | fn description(&self) -> &str {
  function full_fledge_hyphen (line 196) | fn full_fledge_hyphen() {
  function full_fleshed_space (line 207) | fn full_fleshed_space() {
  function full_fleshed_webscraper_hyphen (line 216) | fn full_fleshed_webscraper_hyphen() {
  function full_fleshed_implementation_hyphen (line 225) | fn full_fleshed_implementation_hyphen() {
  function full_pledged_space (line 234) | fn full_pledged_space() {
  function full_pledged_hyphen (line 243) | fn full_pledged_hyphen() {
  function not_fully_fledged_out (line 256) | fn not_fully_fledged_out() {
  function fully_fledged_out (line 269) | fn fully_fledged_out() {
  function fully_fleshed_space (line 282) | fn fully_fleshed_space() {
  function fully_fleshed_hyphen (line 295) | fn fully_fleshed_hyphen() {
  function fully_pledged_space (line 308) | fn fully_pledged_space() {
  function fledge_out (line 319) | fn fledge_out() {
  function fledged_out_space (line 330) | fn fledged_out_space() {

FILE: harper-core/src/linting/for_noun.rs
  type ForNoun (line 12) | pub struct ForNoun {
  method default (line 17) | fn default() -> Self {
  type Unit (line 27) | type Unit = Chunk;
  method expr (line 29) | fn expr(&self) -> &dyn Expr {
  method match_to_lint (line 33) | fn match_to_lint(&self, matched_tokens: &[Token], source: &[char]) -> Op...
  method description (line 49) | fn description(&self) -> &'static str {
  function corrects_fro_basic_correction (line 60) | fn corrects_fro_basic_correction() {
  function allows_for_clean (line 69) | fn allows_for_clean() {
  function corrects_fro_sure (line 74) | fn corrects_fro_sure() {

FILE: harper-core/src/linting/free_predicate.rs
  type FreePredicate (line 10) | pub struct FreePredicate {
  method default (line 15) | fn default() -> Self {
  type Unit (line 41) | type Unit = Chunk;
  method expr (line 43) | fn expr(&self) -> &dyn Expr {
  method match_to_lint (line 47) | fn match_to_lint(&self, matched_tokens: &[Token], source: &[char]) -> Op...
  method description (line 63) | fn description(&self) -> &'static str {
  function matches_fee (line 68) | fn matches_fee(token: &Token, source: &[char]) -> bool {
  function follows_fee (line 83) | fn follows_fee(token: &Token, _source: &[char]) -> bool {
  function linking_like (line 93) | fn linking_like(token: &Token, source: &[char]) -> bool {
  function corrects_is_fee_for (line 109) | fn corrects_is_fee_for() {
  function corrects_totally_fee (line 118) | fn corrects_totally_fee() {
  function corrects_really_fee_to (line 127) | fn corrects_really_fee_to() {
  function corrects_fee_with_comma (line 136) | fn corrects_fee_with_comma() {
  function corrects_fee_period (line 145) | fn corrects_fee_period() {
  function corrects_fee_past_tense (line 154) | fn corrects_fee_past_tense() {
  function allows_fee_based (line 163) | fn allows_fee_based() {
  function allows_fee_paying (line 168) | fn allows_fee_paying() {
  function allows_fee_schedule_statement (line 173) | fn allows_fee_schedule_statement() {
  function allows_fee_free_phrase (line 181) | fn allows_fee_free_phrase() {
  function counts_single_lint (line 189) | fn counts_single_lint() {

FILE: harper-core/src/linting/friend_of_me.rs
  type FriendOfMe (line 8) | pub struct FriendOfMe {
  method default (line 13) | fn default() -> Self {
  type Unit (line 25) | type Unit = Chunk;
  method expr (line 27) | fn expr(&self) -> &dyn Expr {
  method match_to_lint (line 31) | fn match_to_lint(&self, toks: &[Token], src: &[char]) -> Option<Lint> {
  method description (line 59) | fn description(&self) -> &'static str {
  function corrects_friend_of_me (line 70) | fn corrects_friend_of_me() {
  function corrects_friend_of_you (line 79) | fn corrects_friend_of_you() {
  function corrects_friend_of_us (line 88) | fn corrects_friend_of_us() {
  function corrects_friends_of_them (line 97) | fn corrects_friends_of_them() {
  function corrects_friend_of_him (line 106) | fn corrects_friend_of_him() {
  function corrects_friends_of_me (line 115) | fn corrects_friends_of_me() {
  function corrects_friends_of_us (line 124) | fn corrects_friends_of_us() {

FILE: harper-core/src/linting/go_so_far_as_to.rs
  type GoSoFarAsTo (line 8) | pub struct GoSoFarAsTo {
  method default (line 13) | fn default() -> Self {
  type Unit (line 24) | type Unit = Chunk;
  method expr (line 26) | fn expr(&self) -> &dyn Expr {
  method match_to_lint (line 30) | fn match_to_lint(&self, toks: &[Token], src: &[char]) -> Option<Lint> {
  method description (line 71) | fn description(&self) -> &'static str {
  function go_so_far_to (line 82) | fn go_so_far_to() {
  function goes_so_far_to (line 91) | fn goes_so_far_to() {
  function gone_so_far_to (line 100) | fn gone_so_far_to() {
  function went_so_far_to (line 109) | fn went_so_far_to() {
  function went_so_far_to_adverb (line 118) | fn went_so_far_to_adverb() {
  function dont_flag_going_so_far_to (line 128) | fn dont_flag_going_so_far_to() {
  function dont_flag_goes_so_far_to (line 136) | fn dont_flag_goes_so_far_to() {
  function dont_flag_go_so_far_to (line 144) | fn dont_flag_go_so_far_to() {

FILE: harper-core/src/linting/go_to_war.rs
  type GoToWar (line 7) | pub struct GoToWar {
  method default (line 12) | fn default() -> Self {
  type Unit (line 24) | type Unit = Chunk;
  method description (line 26) | fn description(&self) -> &str {
  metho

[
  {
    "path": ".dockerignore",
    "chars": 32,
    "preview": "target\nbuild\n*.pdf\nnode_modules\n"
  },
  {
    "path": ".editorconfig",
    "chars": 34,
    "preview": "root = true\n\n[*]\nend_of_line = lf\n"
  },
  {
    "path": ".envrc",
    "chars": 10,
    "preview": "use flake\n"
  },
  {
    "path": ".gitattributes",
    "chars": 96,
    "preview": "* text=auto eol=lf\nquill_simple.html linguist-generated\ngithub_textarea.html linguist-generated\n"
  },
  {
    "path": ".github/ISSUE_TEMPLATE/bug_report.md",
    "chars": 662,
    "preview": "---\nname: Bug report\nabout: Create a report to help us improve\ntitle: ''\nlabels: bug\nassignees: ''\n\n---\n\n**Describe the "
  },
  {
    "path": ".github/ISSUE_TEMPLATE/report-false-positive.md",
    "chars": 310,
    "preview": "---\nname: Report False Positive\nabout: Harper flagged something that's actually correct\ntitle: ''\nlabels: bug, harper-co"
  },
  {
    "path": ".github/ISSUE_TEMPLATE/report-grammatical-error.md",
    "chars": 319,
    "preview": "---\nname: Report Grammatical Error\nabout: Harper missed a grammatical error\ntitle: ''\nlabels: enhancement, harper-core, "
  },
  {
    "path": ".github/ISSUE_TEMPLATE/suggest-a-feature.md",
    "chars": 342,
    "preview": "---\nname: Suggest a Feature\nabout: Propose a new feature\ntitle: ''\nlabels: enhancement\n---\n**What problem does this solv"
  },
  {
    "path": ".github/dependabot.yml",
    "chars": 196,
    "preview": "version: 2\nupdates:\n  - package-ecosystem: \"cargo\"\n    directory: \"/\"\n    schedule:\n      interval: \"weekly\"\n  - package"
  },
  {
    "path": ".github/pull_request_template.md",
    "chars": 740,
    "preview": "# Issues \n<!-- Link any relevant GitHub issues here. -->\n<!-- If this PR resolves the issue(s), write closes/fixes/resol"
  },
  {
    "path": ".github/workflows/binaries.yml",
    "chars": 5309,
    "preview": "name: Binaries\n\non:\n  push:\n    branches: [\"master\"]\n    tags: [\"v*\"]\n  merge_group:\n\njobs:\n  binaries:\n    name: ${{ ma"
  },
  {
    "path": ".github/workflows/build_web.yml",
    "chars": 766,
    "preview": "name: Build Web\n\non:\n  push:\n    branches: [\"master\", \"web-prod\"]\n  pull_request:\n    branches: [\"master\"]\n  merge_group"
  },
  {
    "path": ".github/workflows/chrome_plugin.yml",
    "chars": 1405,
    "preview": "name: Chrome Plugin\n\non:\n  push:\n    branches: [\"master\"]\n    tags: [\"v*\"]\n  pull_request:\n    branches: [\"master\"]\n  me"
  },
  {
    "path": ".github/workflows/just_checks.yml",
    "chars": 1332,
    "preview": "name: Just Checks\n\non:\n  push:\n    branches: [\"master\", \"web-prod\"]\n  pull_request:\n    branches: [\"master\"]\n  merge_gro"
  },
  {
    "path": ".github/workflows/stale.yml",
    "chars": 1535,
    "preview": "# Adapted from [Jeff Geerling's Stale Workflow](https://github.com/geerlingguy/mac-dev-playbook/blob/719de3569804fcf4974"
  },
  {
    "path": ".github/workflows/vscode_plugin.yml",
    "chars": 3468,
    "preview": "name: VS Code Plugin\n\non:\n  push:\n    branches: [\"master\"]\n    tags: [\"v*\"]\n  merge_group:\n\njobs:\n  vscode-plugin:\n    n"
  },
  {
    "path": ".github/workflows/wp_plugin.yml",
    "chars": 1050,
    "preview": "name: WordPress Plugin\n\non:\n  push:\n    branches: [\"master\"]\n    tags: [\"v*\"]\n  pull_request:\n    branches: [\"master\"]\n "
  },
  {
    "path": ".gitignore",
    "chars": 102,
    "preview": "target\nbuild\n.idea\n.vscode\n.DS_Store\n*.pdf\nnode_modules\nmariadb_data\n\n# Ignore direnv files\n.direnv/*\n"
  },
  {
    "path": ".node-version",
    "chars": 5,
    "preview": "lts/*"
  },
  {
    "path": ".npmrc",
    "chars": 36,
    "preview": "registry=https://registry.npmjs.org\n"
  },
  {
    "path": "AGENTS.md",
    "chars": 11009,
    "preview": "# Harper Docs Map for Agents\n\nThis repository’s documentation site is powered by Vite + SvelteKit + SveltePress.\n\nUse `p"
  },
  {
    "path": "ARCHITECTURE.md",
    "chars": 145,
    "preview": "# Harper's Architecture\n\nThis document has been moved to the [online documentation](https://writewithharper.com/docs/con"
  },
  {
    "path": "COMPARISON.md",
    "chars": 1751,
    "preview": "# Comparison to Other Grammar Checkers\n\n|              | Suggestion Time | License                  | LSP Support       "
  },
  {
    "path": "CONTRIBUTING.md",
    "chars": 130,
    "preview": "# Contributing\n\nThis page has been moved to [the main documentation](https://writewithharper.com/docs/contributors/intro"
  },
  {
    "path": "Cargo.toml",
    "chars": 712,
    "preview": "[workspace]\nmembers = [\"harper-cli\", \"harper-core\", \"harper-ls\", \"harper-comments\", \"harper-wasm\", \"harper-tree-sitter\","
  },
  {
    "path": "Dockerfile",
    "chars": 1509,
    "preview": "# This Dockerfile is for the Harper website and web services.\n# You do not need it to use Harper.\n\nARG NODE_VERSION=24\n\n"
  },
  {
    "path": "LICENSE",
    "chars": 11343,
    "preview": "                                 Apache License\n                           Version 2.0, January 2004\n                   "
  },
  {
    "path": "README.md",
    "chars": 3884,
    "preview": "<div id=\"header\" align=\"center\">\n    <img src=\"logo.svg\" width=\"400px\" />\n    <h1>Harper</h1>\n</div>\n\n[![Harper Binaries"
  },
  {
    "path": "biome.json",
    "chars": 2244,
    "preview": "{\n\t\"$schema\": \"https://biomejs.dev/schemas/2.3.3/schema.json\",\n\t\"vcs\": {\n\t\t\"enabled\": true,\n\t\t\"clientKind\": \"git\",\n\t\t\"us"
  },
  {
    "path": "demo.md",
    "chars": 739,
    "preview": "There are some cases where the the standard grammar\ncheckers don't cut it. That;s where Harper comes in handy.\n\nHarper i"
  },
  {
    "path": "docker-compose.dev.yml",
    "chars": 547,
    "preview": "# This Docker compose file is for development of the Harper website and web services.\n# You do not need it to use Harper"
  },
  {
    "path": "docker-compose.yml",
    "chars": 822,
    "preview": "# This Docker compose file is for development of the Harper website and web services.\n# You do not need it to use Harper"
  },
  {
    "path": "flake.nix",
    "chars": 2893,
    "preview": "{\n  inputs = {\n    utils.url = \"github:numtide/flake-utils\";\n  };\n  outputs =\n    {\n      self,\n      nixpkgs,\n      uti"
  },
  {
    "path": "fuzz/.gitignore",
    "chars": 33,
    "preview": "target\ncorpus\nartifacts\ncoverage\n"
  },
  {
    "path": "fuzz/Cargo.toml",
    "chars": 1026,
    "preview": "[package]\nname = \"fuzz\"\nversion = \"0.0.0\"\npublish = false\nedition = \"2024\"\n\n[package.metadata]\ncargo-fuzz = true\n\n[depen"
  },
  {
    "path": "fuzz/README.md",
    "chars": 1336,
    "preview": "# cargo-fuzz targets\n\n## Setup\n\nFollow the rust-fuzz [setup guide](https://rust-fuzz.github.io/book/cargo-fuzz/setup.htm"
  },
  {
    "path": "fuzz/fuzz_targets/fuzz_harper_comment.rs",
    "chars": 1642,
    "preview": "#![no_main]\n\nuse harper_core::parsers::{MarkdownOptions, StrParser};\nuse libfuzzer_sys::arbitrary::{Arbitrary, Result, U"
  },
  {
    "path": "fuzz/fuzz_targets/fuzz_harper_core_markdown.rs",
    "chars": 264,
    "preview": "#![no_main]\n\nuse harper_core::parsers::{Markdown, MarkdownOptions, StrParser};\nuse libfuzzer_sys::fuzz_target;\n\nfuzz_tar"
  },
  {
    "path": "fuzz/fuzz_targets/fuzz_harper_html.rs",
    "chars": 207,
    "preview": "#![no_main]\n\nuse harper_core::parsers::StrParser;\nuse libfuzzer_sys::fuzz_target;\n\nfuzz_target!(|data: &str| {\n    let p"
  },
  {
    "path": "fuzz/fuzz_targets/fuzz_harper_literate_haskell.rs",
    "chars": 225,
    "preview": "#![no_main]\n\n// use harper_core::parsers::StrParser;\nuse libfuzzer_sys::fuzz_target;\n\nfuzz_target!(|_data: &str| {\n    /"
  },
  {
    "path": "fuzz/fuzz_targets/fuzz_harper_typst.rs",
    "chars": 190,
    "preview": "#![no_main]\n\nuse harper_core::parsers::StrParser;\nuse libfuzzer_sys::fuzz_target;\n\nfuzz_target!(|data: &str| {\n    let t"
  },
  {
    "path": "harper-asciidoc/Cargo.toml",
    "chars": 443,
    "preview": "[package]\nname = \"harper-asciidoc\"\nversion = \"1.12.0\"\nedition = \"2024\"\ndescription = \"The language checker for developer"
  },
  {
    "path": "harper-asciidoc/src/lib.rs",
    "chars": 1047,
    "preview": "use harper_core::parsers::{self, Parser, PlainEnglish};\nuse harper_core::{Token, TokenKind};\nuse harper_tree_sitter::Tre"
  },
  {
    "path": "harper-asciidoc/tests/asciidoc_tests.rs",
    "chars": 1487,
    "preview": "use harper_asciidoc::AsciidocParser;\nuse harper_core::linting::{LintGroup, Linter};\nuse harper_core::spell::FstDictionar"
  },
  {
    "path": "harper-asciidoc/tests/test_sources/basic.adoc",
    "chars": 73,
    "preview": "= This is a titlle\n\nThis is a basic paragraph with a typo here: mstakes.\n"
  },
  {
    "path": "harper-asciidoc/tests/test_sources/comment.adoc",
    "chars": 78,
    "preview": "// This is a comment with a typo: spelll\n// Another line of the same comment.\n"
  },
  {
    "path": "harper-asciidoc/tests/test_sources/comprehensive.adoc",
    "chars": 497,
    "preview": "= Document Title\nAuthor Name <author@example.com>\n:revdate: 2026-01-01\n:custom-attr: Value with typpo.\n\nThis is a paragr"
  },
  {
    "path": "harper-asciidoc/tests/test_sources/table.adoc",
    "chars": 53,
    "preview": "|===\n| Cell 1 | Cell 2, but with a typo: errorr\n|===\n"
  },
  {
    "path": "harper-brill/Cargo.toml",
    "chars": 352,
    "preview": "[package]\nname = \"harper-brill\"\nversion = \"1.12.0\"\nedition = \"2024\"\ndescription = \"The language checker for developers.\""
  },
  {
    "path": "harper-brill/finished_chunker/vocab.json",
    "chars": 627232,
    "preview": "{\n\t\"kicked\": 8723,\n\t\"ADPL\": 12418,\n\t\"Stirling\": 4479,\n\t\"proper\": 1178,\n\t\"blond-haired\": 30464,\n\t\"unitary\": 14934,\n\t\"hype"
  },
  {
    "path": "harper-brill/src/lib.rs",
    "chars": 2028,
    "preview": "use std::num::NonZero;\nuse std::rc::Rc;\nuse std::sync::{Arc, LazyLock};\n\npub use harper_pos_utils::{\n    BrillChunker, B"
  },
  {
    "path": "harper-brill/trained_chunker_model.json",
    "chars": 52717,
    "preview": "{\n\t\"base\": {\n\t\t\"counts\": {\n\t\t\t\"ADP\": -40685,\n\t\t\t\"VERB\": -47220,\n\t\t\t\"CCONJ\": -14576,\n\t\t\t\"PROPN\": 17155,\n\t\t\t\"ADJ\": -8207,\n"
  },
  {
    "path": "harper-brill/trained_tagger_model.json",
    "chars": 659439,
    "preview": "{\n\t\"base\": {\n\t\t\"mapping\": {\n\t\t\t\"dame\": \"PROPN\",\n\t\t\t\"associate\": \"NOUN\",\n\t\t\t\"obscurity\": \"NOUN\",\n\t\t\t\"ivan\": \"PROPN\",\n\t\t\t\""
  },
  {
    "path": "harper-cli/Cargo.toml",
    "chars": 1298,
    "preview": "[package]\nname = \"harper-cli\"\nversion = \"0.1.0\"\nedition = \"2024\"\npublish = false\nrepository = \"https://github.com/automa"
  },
  {
    "path": "harper-cli/README.md",
    "chars": 508,
    "preview": "# `harper-cli`\n\n## What?\n\n`harper-cli` is a small, experimental frontend for Harper.\nIt can be used in any situation whe"
  },
  {
    "path": "harper-cli/src/annotate.rs",
    "chars": 6089,
    "preview": "use std::{borrow::Cow, ops::Range};\n\nuse ariadne::{Color, Label, Report, ReportKind};\nuse clap::ValueEnum;\nuse harper_co"
  },
  {
    "path": "harper-cli/src/input/multi_input.rs",
    "chars": 2399,
    "preview": "use std::{borrow::Cow, path::PathBuf};\n\nuse enum_dispatch::enum_dispatch;\nuse strum_macros::EnumTryAs;\n\nuse crate::input"
  },
  {
    "path": "harper-cli/src/input/single_input.rs",
    "chars": 6930,
    "preview": "use std::path::Path;\nuse std::{borrow::Cow, io::Read, path::PathBuf};\n\nuse enum_dispatch::enum_dispatch;\nuse strum_macro"
  },
  {
    "path": "harper-cli/src/input.rs",
    "chars": 2097,
    "preview": "use std::borrow::Cow;\n\nuse enum_dispatch::enum_dispatch;\nuse strum_macros::EnumTryAs;\n\npub mod single_input;\nuse single_"
  },
  {
    "path": "harper-cli/src/lint.rs",
    "chars": 33055,
    "preview": "use std::borrow::Cow;\nuse std::collections::BTreeMap;\nuse std::path::{Component, Path, PathBuf};\nuse std::sync::Arc;\nuse"
  },
  {
    "path": "harper-cli/src/main.rs",
    "chars": 38831,
    "preview": "#![doc = include_str!(\"../README.md\")]\n\nuse harper_core::spell::{Dictionary, FstDictionary, MutableDictionary, WordId};\n"
  },
  {
    "path": "harper-cli/tests/no_color.rs",
    "chars": 1384,
    "preview": "use std::process::Command;\n\nfn harper_cli() -> Command {\n    Command::new(env!(\"CARGO_BIN_EXE_harper-cli\"))\n}\n\n/// Input"
  },
  {
    "path": "harper-cli/tests/output_format.rs",
    "chars": 5270,
    "preview": "use std::io::Write;\nuse std::process::Command;\n\nfn harper_cli() -> Command {\n    Command::new(env!(\"CARGO_BIN_EXE_harper"
  },
  {
    "path": "harper-comments/Cargo.toml",
    "chars": 1246,
    "preview": "[package]\nname = \"harper-comments\"\nversion = \"1.12.0\"\nedition = \"2024\"\ndescription = \"The language checker for developer"
  },
  {
    "path": "harper-comments/README.md",
    "chars": 412,
    "preview": "# `harper-comments`\n\nThis crate holds a number of functions, but it is primarily a wrapper around `tree-sitter` that all"
  },
  {
    "path": "harper-comments/src/comment_parser.rs",
    "chars": 5590,
    "preview": "use std::path::Path;\n\nuse crate::comment_parsers;\nuse comment_parsers::{Go, JavaDoc, JsDoc, Lua, Solidity, Unit};\nuse ha"
  },
  {
    "path": "harper-comments/src/comment_parsers/go.rs",
    "chars": 1234,
    "preview": "use harper_core::Lrc;\nuse harper_core::Token;\nuse harper_core::parsers::{Markdown, MarkdownOptions, Parser};\n\nuse super:"
  },
  {
    "path": "harper-comments/src/comment_parsers/javadoc.rs",
    "chars": 2297,
    "preview": "use std::collections::VecDeque;\n\nuse harper_core::parsers::Parser;\nuse harper_core::{Punctuation, Token, TokenKind, VecE"
  },
  {
    "path": "harper-comments/src/comment_parsers/jsdoc.rs",
    "chars": 6650,
    "preview": "use harper_core::Lrc;\nuse harper_core::parsers::{Markdown, MarkdownOptions, Parser};\nuse harper_core::{Punctuation, Span"
  },
  {
    "path": "harper-comments/src/comment_parsers/lua.rs",
    "chars": 2101,
    "preview": "use harper_core::Lrc;\nuse harper_core::Span;\nuse harper_core::Token;\nuse harper_core::parsers::{Markdown, MarkdownOption"
  },
  {
    "path": "harper-comments/src/comment_parsers/mod.rs",
    "chars": 1340,
    "preview": "mod go;\nmod javadoc;\nmod jsdoc;\nmod lua;\nmod solidity;\nmod unit;\n\npub use go::Go;\nuse harper_core::Span;\npub use javadoc"
  },
  {
    "path": "harper-comments/src/comment_parsers/solidity.rs",
    "chars": 2109,
    "preview": "use harper_core::Lrc;\nuse harper_core::Span;\nuse harper_core::Token;\nuse harper_core::parsers::{MarkdownOptions, Parser}"
  },
  {
    "path": "harper-comments/src/comment_parsers/unit.rs",
    "chars": 2332,
    "preview": "use harper_core::Lrc;\nuse harper_core::parsers::{Markdown, MarkdownOptions, Parser};\nuse harper_core::{Span, Token};\n\nus"
  },
  {
    "path": "harper-comments/src/lib.rs",
    "chars": 132,
    "preview": "#![doc = include_str!(\"../README.md\")]\n\nmod comment_parser;\nmod comment_parsers;\nmod masker;\npub use comment_parser::Com"
  },
  {
    "path": "harper-comments/src/masker.rs",
    "chars": 1939,
    "preview": "use harper_core::Masker;\nuse harper_core::spell::MutableDictionary;\nuse harper_tree_sitter::TreeSitterMasker;\n\npub struc"
  },
  {
    "path": "harper-comments/tests/language_support.rs",
    "chars": 3126,
    "preview": "use std::path::Path;\n\nuse harper_comments::CommentParser;\nuse harper_core::linting::{LintGroup, Linter};\nuse harper_core"
  },
  {
    "path": "harper-comments/tests/language_support_sources/basic.clj",
    "chars": 1869,
    "preview": "(ns clean\n  \"It is actually possible to document a ns.\n  It's a nice place to describe the purpose of the namespace and "
  },
  {
    "path": "harper-comments/tests/language_support_sources/basic_groovy.groovy",
    "chars": 54,
    "preview": "// This commment has one typo.\ndef greeting = \"hello\"\n"
  },
  {
    "path": "harper-comments/tests/language_support_sources/basic_kotlin.kt",
    "chars": 5253,
    "preview": "// *************************************************************************************************\n//  A diminutive bu"
  },
  {
    "path": "harper-comments/tests/language_support_sources/clean.lua",
    "chars": 157,
    "preview": "---@meta\n\n---@alias MyCustomType integer\n\n---Calculate a value using [my custom type](lua://MyCustomType)\n---@param x My"
  },
  {
    "path": "harper-comments/tests/language_support_sources/clean.ps1",
    "chars": 265,
    "preview": "# This is an example PowerShell file with clean comments.\n\n<#\nThis block comment should also lint cleanly.\nIt includes m"
  },
  {
    "path": "harper-comments/tests/language_support_sources/clean.rs",
    "chars": 906,
    "preview": "/// This is an example Rust file that should produce no Harper lints.\n\nstruct TestStruct {}\n\nimpl TestStruct {\n    /// T"
  },
  {
    "path": "harper-comments/tests/language_support_sources/clean.sol",
    "chars": 1048,
    "preview": "// SPDX-License-Identifier: UNLICENSED\npragma solidity ^0.8.20;\n\n/// This is an example Solidity file that should produc"
  },
  {
    "path": "harper-comments/tests/language_support_sources/clean.zig",
    "chars": 228,
    "preview": "//! Top-level module documentation.\n\n/// Main entry point.\npub fn main() void {\n    // Regular comment.\n    const x: i32"
  },
  {
    "path": "harper-comments/tests/language_support_sources/common.mill",
    "chars": 498,
    "preview": "import mill._, scalalib._\n\nobject hello extends ScalaModule {\n  def scalaVersion = \"2.13.8\"\n\n  // Define third-party dep"
  },
  {
    "path": "harper-comments/tests/language_support_sources/complex_gradle_build.gradle",
    "chars": 366,
    "preview": "plugins {\n    id 'java-library'\n}\n\nrepositories {\n    mavenCentral()\n}\n\ndependencies {\n    implementation 'org.slf4j:slf"
  },
  {
    "path": "harper-comments/tests/language_support_sources/complex_groovy_block_comments.groovy",
    "chars": 635,
    "preview": "/*\n * This module-level commment sits above imports and class declarations.\n * It intentionally includes punctuation, sy"
  },
  {
    "path": "harper-comments/tests/language_support_sources/complex_groovy_strings_regex.groovy",
    "chars": 343,
    "preview": "class ParserLikeExample {\n    static void main(String[] args) {\n        String url = \"https://example.com/path?foo=bar//"
  },
  {
    "path": "harper-comments/tests/language_support_sources/dirty.lua",
    "chars": 189,
    "preview": "---@meta\n\n---@alias MyCustomType integer\n\n---Calculate a value using [my custom type](lua://MyCustomType)\n---\n--- This c"
  },
  {
    "path": "harper-comments/tests/language_support_sources/dirty.zig",
    "chars": 223,
    "preview": "//! This module demonstrates various comment types.\n\n/// This doc comment has a mispelling: teh quick brown fox.\npub fn "
  },
  {
    "path": "harper-comments/tests/language_support_sources/empty.js",
    "chars": 51,
    "preview": "// This is an empty file, apart from this comment.\n"
  },
  {
    "path": "harper-comments/tests/language_support_sources/eof.rs",
    "chars": 95,
    "preview": "fn main() {}\n// This is a test to ensure Harper doesn't crash on comments at the end of files.\n"
  },
  {
    "path": "harper-comments/tests/language_support_sources/ignore_comments.c",
    "chars": 93,
    "preview": "// This comment is spellcheckd\nint main() {\n  // spellchecker:ignore Thear be code in here\n}\n"
  },
  {
    "path": "harper-comments/tests/language_support_sources/ignore_comments.ps1",
    "chars": 232,
    "preview": "# spellcheck:ignore splling error\n# Ths applies to this entire comment block.\n\n$foo = 1\n\n# spellchecker: ignore ths vari"
  },
  {
    "path": "harper-comments/tests/language_support_sources/ignore_comments.rs",
    "chars": 206,
    "preview": "/// spellcheck:ignore splling error\n/// This applies to the entire comment block\n#[derive(Debug)]\n/// Ths comment block "
  },
  {
    "path": "harper-comments/tests/language_support_sources/ignore_comments.sol",
    "chars": 315,
    "preview": "// SPDX-License-Identifier: UNLICENSED\npragma solidity ^0.8.20;\n\n/// spellcheck:ignore splling error\n/// Ths applies to "
  },
  {
    "path": "harper-comments/tests/language_support_sources/ignore_shebang_1.sh",
    "chars": 74,
    "preview": "#!/bin/sh\n# This is a test to make sure that we don't lint shebang lines.\n"
  },
  {
    "path": "harper-comments/tests/language_support_sources/ignore_shebang_2.sh",
    "chars": 83,
    "preview": "#! /usr/bin/env sh\n# This is a test to make sure that we don't lint shebang lines.\n"
  },
  {
    "path": "harper-comments/tests/language_support_sources/ignore_shebang_3.sh",
    "chars": 83,
    "preview": "#!/usr/bin/python3\n# This is a test to make sure that we don't lint shebang lines.\n"
  },
  {
    "path": "harper-comments/tests/language_support_sources/ignore_shebang_4.sh",
    "chars": 83,
    "preview": "#/bin/sh\n# This is a test to make sure that we don't ignore invalid shebang lines.\n"
  },
  {
    "path": "harper-comments/tests/language_support_sources/issue_1097.lua",
    "chars": 133,
    "preview": "---Starting with something capitalized, but without dot at the end\n---@type table<string, string>\nlocal f = {} -- ending"
  },
  {
    "path": "harper-comments/tests/language_support_sources/issue_132.rs",
    "chars": 115,
    "preview": "/// ```\n/// println!(\"Test\");\n/// ```\n///\n/// This shoud get checked.\nfn main() {\n    println!(\"Hello, world!\");\n}\n"
  },
  {
    "path": "harper-comments/tests/language_support_sources/issue_229.c",
    "chars": 3,
    "preview": "// "
  },
  {
    "path": "harper-comments/tests/language_support_sources/issue_229.cs",
    "chars": 3,
    "preview": "// "
  },
  {
    "path": "harper-comments/tests/language_support_sources/issue_229.js",
    "chars": 3,
    "preview": "// "
  },
  {
    "path": "harper-comments/tests/language_support_sources/issue_96.lua",
    "chars": 459,
    "preview": "-- Below, we have a situation where the line terminates and should end the sentence.\n\nlocal alphabet = {\n  [1] = \"a\",  -"
  },
  {
    "path": "harper-comments/tests/language_support_sources/issue_96.rb",
    "chars": 364,
    "preview": "# Below, we have a situation where the line terminates and should end the sentence.\n\nalphabet = [\n \"a\",  # This is a tes"
  },
  {
    "path": "harper-comments/tests/language_support_sources/javadoc_clean_simple.java",
    "chars": 194,
    "preview": "class TestClass {\n\n  /**\n   * This is a JavaDoc without any of the fancy frills that come with it.\n   */\n  public static"
  },
  {
    "path": "harper-comments/tests/language_support_sources/javadoc_complex.java",
    "chars": 704,
    "preview": "class TestClass {\n  /**\n   * This is a JavaDoc with <i>many</i> of the fancy frills that come with it.\n   *\n   * <p>\n   "
  },
  {
    "path": "harper-comments/tests/language_support_sources/jsdoc.ts",
    "chars": 616,
    "preview": "/** This is a doc comment.\n  * Since there are no keywords it _sould_ be checked. */\nfunction test(){}\n\n/** This is also"
  },
  {
    "path": "harper-comments/tests/language_support_sources/laravel_app.php",
    "chars": 4283,
    "preview": "<?php\n\nreturn [\n\n    /*\n    |--------------------------------------------------------------------------\n    | Applicatio"
  },
  {
    "path": "harper-comments/tests/language_support_sources/merged_lines.ts",
    "chars": 410,
    "preview": "// This is a test to make sure we don't split up paragraphs on newlines.\n// This should be the same sentence,\n// this sh"
  },
  {
    "path": "harper-comments/tests/language_support_sources/multiline_comments.cpp",
    "chars": 326,
    "preview": "/// This is an example of an problematic comment.\n/// It should produce one error.\nint test() {}\n\n/***\n * This is an exa"
  },
  {
    "path": "harper-comments/tests/language_support_sources/multiline_comments.sol",
    "chars": 392,
    "preview": "// SPDX-License-Identifier: UNLICENSED\npragma solidity ^0.8.20;\n\n/// This is an example of an problematic comment.\n/// I"
  },
  {
    "path": "harper-comments/tests/language_support_sources/multiline_comments.ts",
    "chars": 332,
    "preview": "// This is an example of an problematic comment\n// It should produce one error\nfunction test() {}\n\n/***\n * This is an ex"
  },
  {
    "path": "harper-core/Cargo.toml",
    "chars": 1498,
    "preview": "[package]\nname = \"harper-core\"\nversion = \"1.12.0\"\nedition = \"2024\"\ndescription = \"The language checker for developers.\"\n"
  },
  {
    "path": "harper-core/README.md",
    "chars": 1744,
    "preview": "# `harper-core`\n\n`harper-core` is the fundamental engine behind [Harper](https://writewithharper.com), the private gramm"
  },
  {
    "path": "harper-core/annotations.json",
    "chars": 17065,
    "preview": "{\n\t\"affixes\": {\n\t\t\"K\": {\n\t\t\t\"#\": \"'pro-' prefix\",\n\t\t\t\"kind\": \"prefix\",\n\t\t\t\"cross_product\": true,\n\t\t\t\"replacements\": [\n\t\t"
  },
  {
    "path": "harper-core/benches/essay.md",
    "chars": 11406,
    "preview": "The question of why we do anything at all is one of those profound, irritatingly unanswerable riddles that philosophers "
  },
  {
    "path": "harper-core/benches/parse_essay.rs",
    "chars": 1367,
    "preview": "use criterion::{Criterion, criterion_group, criterion_main};\nuse harper_core::linting::{LintGroup, Linter};\nuse harper_c"
  },
  {
    "path": "harper-core/build.rs",
    "chars": 1292,
    "preview": "use std::{env, fs, path::PathBuf};\n\nfn main() {\n    let manifest_dir = PathBuf::from(env::var(\"CARGO_MANIFEST_DIR\").unwr"
  },
  {
    "path": "harper-core/clippy.toml",
    "chars": 78,
    "preview": "disallowed-types = [\"std::collections::HashMap\", \"std::collections::HashSet\"]\n"
  },
  {
    "path": "harper-core/dictionary.dict",
    "chars": 775241,
    "preview": "54500\n\n# Start of original dictionary import\n# combined with dialect spelling dictionary import.\n# This section is sorte"
  },
  {
    "path": "harper-core/irregular_nouns.json",
    "chars": 4439,
    "preview": "[\n\t\"// comments can appear in the line before an entry\",\n\t\"// or in place of an entry\",\n\t[\"addendum\", \"addenda\"],\n\t[\"air"
  },
  {
    "path": "harper-core/irregular_verbs.json",
    "chars": 4242,
    "preview": "[\n\t\"// comments can appear in the line before an entry\",\n\t\"// or in place of an entry\",\n\t[\"arise\", \"arose\", \"arisen\"],\n\t"
  },
  {
    "path": "harper-core/proper_noun_rules.json",
    "chars": 13814,
    "preview": "{\n\t\"Americas\": {\n\t\t\"canonical\": [\"South America\", \"North America\", \"Central America\"],\n\t\t\"description\": \"When referring "
  },
  {
    "path": "harper-core/src/case.rs",
    "chars": 3389,
    "preview": "use std::borrow::Borrow;\n\nuse smallvec::SmallVec;\n\nuse crate::{CharString, char_string::CHAR_STRING_INLINE_SIZE};\n\n/// A"
  },
  {
    "path": "harper-core/src/char_ext.rs",
    "chars": 3696,
    "preview": "use unicode_script::{Script, UnicodeScript};\nuse unicode_width::UnicodeWidthChar;\n\nuse crate::Punctuation;\n\nmod private "
  },
  {
    "path": "harper-core/src/char_string.rs",
    "chars": 8588,
    "preview": "use crate::char_ext::CharExt;\nuse std::borrow::Cow;\n\nuse smallvec::SmallVec;\n\n// TODO: remove this when `SmallVec` allow"
  },
  {
    "path": "harper-core/src/currency.rs",
    "chars": 2189,
    "preview": "use is_macro::Is;\nuse serde::{Deserialize, Serialize};\n\nuse crate::Number;\n\n/// A national or international currency\n#[d"
  },
  {
    "path": "harper-core/src/dict_word_metadata.rs",
    "chars": 65925,
    "preview": "use harper_brill::UPOS;\nuse is_macro::Is;\nuse itertools::Itertools;\nuse paste::paste;\nuse serde::{Deserialize, Serialize"
  },
  {
    "path": "harper-core/src/dict_word_metadata_orthography.rs",
    "chars": 13820,
    "preview": "use crate::CharStringExt;\nuse crate::char_ext::CharExt;\nuse serde::{Deserialize, Serialize};\n\n/// Orthography informatio"
  },
  {
    "path": "harper-core/src/document.rs",
    "chars": 48113,
    "preview": "use std::cmp::Ordering;\nuse std::collections::VecDeque;\nuse std::fmt::Display;\n\nuse harper_brill::{Chunker, Tagger, bril"
  },
  {
    "path": "harper-core/src/edit_distance.rs",
    "chars": 2689,
    "preview": "// Computes the Levenshtein edit distance between two patterns.\n// This is accomplished via a memory-optimized Wagner-Fi"
  },
  {
    "path": "harper-core/src/expr/all.rs",
    "chars": 1173,
    "preview": "use crate::{Span, Token, expr::Expr};\n\n/// An [`Expr`] that matches against tokens if and only if all of its children do"
  },
  {
    "path": "harper-core/src/expr/anchor_end.rs",
    "chars": 1403,
    "preview": "use crate::Token;\n\nuse super::Step;\n\n/// A [`Step`] which will match only if the cursor is over the last non-whitespace "
  },
  {
    "path": "harper-core/src/expr/anchor_start.rs",
    "chars": 1092,
    "preview": "use crate::{Token, TokenStringExt};\n\nuse super::Step;\n\n/// A [`Step`] which will match only if the cursor is over the fi"
  },
  {
    "path": "harper-core/src/expr/duration_expr.rs",
    "chars": 1578,
    "preview": "use crate::patterns::{IndefiniteArticle, WordSet};\nuse crate::{Span, Token};\n\nuse super::{Expr, SequenceExpr, SpelledNum"
  },
  {
    "path": "harper-core/src/expr/expr_map.rs",
    "chars": 1675,
    "preview": "use crate::LSend;\nuse crate::Span;\nuse crate::Token;\n\nuse super::Expr;\n\n/// A map from an [`Expr`] to arbitrary data.\n//"
  },
  {
    "path": "harper-core/src/expr/filter.rs",
    "chars": 2060,
    "preview": "use crate::{Span, Token};\n\nuse super::Expr;\n\n/// An expression that wraps other expressions to build a filter-line pipel"
  },
  {
    "path": "harper-core/src/expr/first_match_of.rs",
    "chars": 874,
    "preview": "use super::Expr;\nuse crate::{Span, Token};\n\n/// A naive expr collection that naively iterates through a list of patterns"
  },
  {
    "path": "harper-core/src/expr/fixed_phrase.rs",
    "chars": 3569,
    "preview": "use crate::parsers::PlainEnglish;\nuse crate::patterns::Word;\nuse crate::{Document, Span, Token, TokenKind};\n\nuse super::"
  },
  {
    "path": "harper-core/src/expr/longest_match_of.rs",
    "chars": 696,
    "preview": "use crate::{Span, Token, expr::Expr};\n\n/// An [`Expr`] that returns the farthest offset of the longest match in a list o"
  },
  {
    "path": "harper-core/src/expr/mergeable_words.rs",
    "chars": 5089,
    "preview": "use std::sync::Arc;\n\nuse super::{Expr, SequenceExpr};\nuse crate::spell::{Dictionary, FstDictionary};\nuse crate::{CharStr"
  },
  {
    "path": "harper-core/src/expr/mod.rs",
    "chars": 6031,
    "preview": "//! An `Expr` is a declarative way to express whether a certain set of tokens fulfill a criteria.\n//!\n//! For example, i"
  },
  {
    "path": "harper-core/src/expr/optional.rs",
    "chars": 668,
    "preview": "use crate::{Span, Token};\n\nuse super::Expr;\n\n/// An optional expression.\n/// Forces the optional expression to always re"
  },
  {
    "path": "harper-core/src/expr/reflexive_pronoun.rs",
    "chars": 6045,
    "preview": "use crate::{\n    Span, Token,\n    expr::{Expr, FirstMatchOf},\n    patterns::WordSet,\n};\n\n// These are considered ungramm"
  },
  {
    "path": "harper-core/src/expr/repeating.rs",
    "chars": 2265,
    "preview": "use super::Expr;\nuse crate::{Span, Token};\n\n/// An expression that will match one or more repetitions of the same expres"
  },
  {
    "path": "harper-core/src/expr/sequence_expr.rs",
    "chars": 23405,
    "preview": "use paste::paste;\n\nuse crate::{\n    CharStringExt, Lrc, Span, Token, TokenKind,\n    expr::{FirstMatchOf, FixedPhrase, Lo"
  },
  {
    "path": "harper-core/src/expr/similar_to_phrase.rs",
    "chars": 2517,
    "preview": "use crate::patterns::{WithinEditDistance, Word};\nuse crate::{Document, Span, Token, TokenKind};\n\nuse super::{Expr, Seque"
  },
  {
    "path": "harper-core/src/expr/space_or_hyphen.rs",
    "chars": 566,
    "preview": "use crate::expr::FirstMatchOf;\nuse crate::patterns::WhitespacePattern;\nuse crate::{Span, Token};\n\nuse super::Expr;\n\n/// "
  },
  {
    "path": "harper-core/src/expr/spelled_number_expr.rs",
    "chars": 6174,
    "preview": "use crate::expr::LongestMatchOf;\nuse crate::patterns::{WhitespacePattern, WordSet};\nuse crate::{Span, Token};\n\nuse super"
  },
  {
    "path": "harper-core/src/expr/step.rs",
    "chars": 624,
    "preview": "use crate::{LSend, Token, patterns::Pattern};\n\n/// An atomic step within a larger expression.\n///\n/// Its principle job "
  },
  {
    "path": "harper-core/src/expr/time_unit_expr.rs",
    "chars": 2257,
    "preview": "use crate::expr::LongestMatchOf;\nuse crate::patterns::WordSet;\nuse crate::{Span, Token};\n\nuse super::Expr;\n\n/// Matches "
  },
  {
    "path": "harper-core/src/expr/unless_step.rs",
    "chars": 738,
    "preview": "use crate::{Token, expr::Expr};\n\nuse super::Step;\n\n/// Provides the ability to use an expression as a condition.\n/// If "
  },
  {
    "path": "harper-core/src/expr/word_expr_group.rs",
    "chars": 1489,
    "preview": "use hashbrown::HashMap;\n\nuse super::first_match_of::FirstMatchOf;\nuse super::{Expr, SequenceExpr};\nuse crate::{CharStrin"
  },
  {
    "path": "harper-core/src/fat_token.rs",
    "chars": 992,
    "preview": "use serde::{Deserialize, Serialize};\n\nuse crate::{CharStringExt, TokenKind};\n\n/// A [`Token`](crate::Token) that holds i"
  },
  {
    "path": "harper-core/src/ignored_lints/lint_context.rs",
    "chars": 1677,
    "preview": "use std::hash::{DefaultHasher, Hash, Hasher};\n\nuse serde::{Deserialize, Serialize};\n\nuse crate::{\n    Document, FatToken"
  },
  {
    "path": "harper-core/src/ignored_lints/mod.rs",
    "chars": 4199,
    "preview": "mod lint_context;\n\nuse hashbrown::HashSet;\npub use lint_context::LintContext;\nuse serde::{Deserialize, Serialize};\n\nuse "
  },
  {
    "path": "harper-core/src/indefinite_article.rs",
    "chars": 6016,
    "preview": "use std::borrow::Cow;\n\nuse itertools::Itertools;\n\nuse crate::case::Case::Upper;\nuse crate::char_ext::CharExt;\nuse crate:"
  },
  {
    "path": "harper-core/src/irregular_nouns.rs",
    "chars": 3209,
    "preview": "use serde::Deserialize;\nuse std::sync::{Arc, LazyLock};\n\ntype Noun = (String, String);\n\n#[derive(Debug, Deserialize)]\npu"
  },
  {
    "path": "harper-core/src/irregular_verbs.rs",
    "chars": 3819,
    "preview": "use serde::Deserialize;\nuse std::sync::{Arc, LazyLock};\n\ntype Verb = (String, String, String);\n\n#[derive(Debug, Deserial"
  },
  {
    "path": "harper-core/src/language_detection.rs",
    "chars": 3886,
    "preview": "//! This module implements rudimentary, dictionary-based English language detection.\n\nuse crate::spell::Dictionary;\nuse "
  },
  {
    "path": "harper-core/src/lexing/email_address.rs",
    "chars": 5469,
    "preview": "use itertools::Itertools;\n\nuse super::FoundToken;\nuse super::hostname::lex_hostname;\nuse crate::TokenKind;\n\n/// The maxi"
  },
  {
    "path": "harper-core/src/lexing/hostname.rs",
    "chars": 2895,
    "preview": "use crate::TokenKind;\n\nuse super::FoundToken;\n\n/// Lex a hostname token.\npub fn lex_hostname_token(source: &[char]) -> O"
  },
  {
    "path": "harper-core/src/lexing/mod.rs",
    "chars": 24629,
    "preview": "mod email_address;\nmod hostname;\nmod url;\n\nuse hostname::lex_hostname_token;\nuse ordered_float::OrderedFloat;\nuse url::l"
  },
  {
    "path": "harper-core/src/lexing/url.rs",
    "chars": 5821,
    "preview": "/// This module implements parsing of URIs.\n/// See RFC 1738 for more information.\nuse super::{FoundToken, hostname::lex"
  },
  {
    "path": "harper-core/src/lib.rs",
    "chars": 6187,
    "preview": "#![doc = include_str!(\"../README.md\")]\n#![allow(dead_code)]\n\nmod case;\nmod char_ext;\nmod char_string;\nmod currency;\nmod "
  },
  {
    "path": "harper-core/src/linting/a_part.rs",
    "chars": 8844,
    "preview": "use crate::expr::Expr;\nuse crate::expr::FirstMatchOf;\nuse crate::expr::FixedPhrase;\nuse crate::linting::expr_linter::Chu"
  },
  {
    "path": "harper-core/src/linting/a_while.rs",
    "chars": 3657,
    "preview": "use harper_brill::UPOS;\n\nuse crate::char_string::char_string;\nuse crate::expr::{Expr, ExprMap, SequenceExpr};\nuse crate:"
  },
  {
    "path": "harper-core/src/linting/addicting.rs",
    "chars": 4137,
    "preview": "use crate::linting::expr_linter::Chunk;\nuse crate::{\n    Token,\n    expr::{All, AnchorEnd, Expr, FirstMatchOf, LongestMa"
  },
  {
    "path": "harper-core/src/linting/adjective_double_degree.rs",
    "chars": 7375,
    "preview": "use crate::linting::expr_linter::Chunk;\nuse crate::{\n    CharStringExt, Token, TokenStringExt,\n    expr::{Expr, Sequence"
  },
  {
    "path": "harper-core/src/linting/adjective_of_a.rs",
    "chars": 20085,
    "preview": "use super::{Lint, LintKind, Linter, Suggestion};\nuse crate::{Document, Span, TokenStringExt};\n\n/// Detect sequences of w"
  },
  {
    "path": "harper-core/src/linting/after_later.rs",
    "chars": 4935,
    "preview": "use crate::Token;\nuse crate::expr::{DurationExpr, Expr, SequenceExpr};\nuse crate::linting::expr_linter::Chunk;\nuse crate"
  },
  {
    "path": "harper-core/src/linting/all_hell_break_loose.rs",
    "chars": 2916,
    "preview": "use crate::{\n    Lint, Token,\n    expr::{Expr, SequenceExpr},\n    linting::{ExprLinter, LintKind, Suggestion, expr_linte"
  },
  {
    "path": "harper-core/src/linting/all_intents_and_purposes.rs",
    "chars": 11679,
    "preview": "use crate::Token;\nuse crate::char_string::CharStringExt;\nuse crate::expr::{Expr, SequenceExpr};\nuse crate::linting::expr"
  },
  {
    "path": "harper-core/src/linting/allow_to.rs",
    "chars": 3217,
    "preview": "use crate::expr::{Expr, SequenceExpr};\nuse crate::linting::expr_linter::Chunk;\nuse crate::linting::{ExprLinter, Lint, Li"
  },
  {
    "path": "harper-core/src/linting/am_in_the_morning.rs",
    "chars": 9928,
    "preview": "use crate::linting::expr_linter::Chunk;\nuse crate::{\n    Span, Token, TokenStringExt,\n    expr::{Expr, FixedPhrase, Long"
  },
  {
    "path": "harper-core/src/linting/amounts_for.rs",
    "chars": 7919,
    "preview": "use crate::expr::Expr;\nuse crate::expr::FirstMatchOf;\nuse crate::expr::SequenceExpr;\nuse crate::{Token, TokenStringExt, "
  },
  {
    "path": "harper-core/src/linting/an_a.rs",
    "chars": 9946,
    "preview": "use itertools::Itertools;\n\nuse crate::indefinite_article::{InitialSound, starts_with_vowel};\nuse crate::linting::{Lint, "
  },
  {
    "path": "harper-core/src/linting/and_in.rs",
    "chars": 2412,
    "preview": "use crate::Token;\nuse crate::expr::{Expr, SequenceExpr};\nuse crate::linting::expr_linter::Chunk;\nuse crate::linting::{Ex"
  },
  {
    "path": "harper-core/src/linting/and_the_like.rs",
    "chars": 5293,
    "preview": "use crate::expr::{All, Expr, FixedPhrase, SequenceExpr};\nuse crate::linting::expr_linter::Chunk;\nuse crate::linting::{Ex"
  },
  {
    "path": "harper-core/src/linting/another_thing_coming.rs",
    "chars": 2779,
    "preview": "use crate::linting::expr_linter::Chunk;\nuse crate::{\n    Token, TokenStringExt,\n    expr::{Expr, SequenceExpr},\n    lint"
  },
  {
    "path": "harper-core/src/linting/another_think_coming.rs",
    "chars": 2824,
    "preview": "use crate::linting::expr_linter::Chunk;\nuse crate::{\n    Token, TokenStringExt,\n    expr::{Expr, SequenceExpr},\n    lint"
  },
  {
    "path": "harper-core/src/linting/apart_from.rs",
    "chars": 3623,
    "preview": "use crate::Token;\nuse crate::expr::{Expr, SequenceExpr};\nuse crate::linting::expr_linter::Chunk;\n\nuse super::{ExprLinter"
  },
  {
    "path": "harper-core/src/linting/ask_no_preposition.rs",
    "chars": 5300,
    "preview": "use crate::expr::Expr;\nuse crate::expr::SequenceExpr;\nuse crate::linting::expr_linter::Chunk;\nuse crate::{\n    Span, Tok"
  },
  {
    "path": "harper-core/src/linting/avoid_curses.rs",
    "chars": 9593,
    "preview": "use crate::Token;\nuse crate::expr::{Expr, SequenceExpr};\nuse crate::linting::{LintKind, Suggestion};\n\nuse super::{ExprLi"
  },
  {
    "path": "harper-core/src/linting/back_in_the_day.rs",
    "chars": 5542,
    "preview": "use crate::expr::Expr;\nuse crate::expr::FixedPhrase;\nuse crate::expr::LongestMatchOf;\nuse crate::expr::OwnedExprExt;\nuse"
  },
  {
    "path": "harper-core/src/linting/be_allowed.rs",
    "chars": 4863,
    "preview": "use crate::linting::expr_linter::Chunk;\nuse crate::{\n    Token,\n    expr::{Expr, ExprMap, SequenceExpr},\n    linting::{E"
  },
  {
    "path": "harper-core/src/linting/be_worried.rs",
    "chars": 7324,
    "preview": "use crate::{\n    CharStringExt, Token,\n    expr::{All, Expr, OwnedExprExt, SequenceExpr},\n    linting::{\n        ExprLin"
  },
  {
    "path": "harper-core/src/linting/behind_the_scenes.rs",
    "chars": 2753,
    "preview": "use crate::{\n    Lint, Token,\n    expr::{Expr, SequenceExpr},\n    linting::{ExprLinter, LintKind, Suggestion, expr_linte"
  },
  {
    "path": "harper-core/src/linting/best_of_all_time.rs",
    "chars": 6005,
    "preview": "use crate::Token;\nuse crate::expr::{Expr, SequenceExpr};\nuse crate::linting::{ExprLinter, Lint, LintKind, Suggestion, ex"
  },
  {
    "path": "harper-core/src/linting/boring_words.rs",
    "chars": 1577,
    "preview": "use itertools::Itertools;\n\nuse crate::expr::{Expr, FirstMatchOf, WordExprGroup};\nuse crate::thesaurus_helper;\nuse crate:"
  },
  {
    "path": "harper-core/src/linting/bought.rs",
    "chars": 4314,
    "preview": "use super::{ExprLinter, Lint, LintKind};\nuse crate::Token;\nuse crate::expr::{Expr, SequenceExpr};\nuse crate::linting::Su"
  },
  {
    "path": "harper-core/src/linting/brand_brandish.rs",
    "chars": 7476,
    "preview": "use crate::{\n    Lint, Token, TokenKind,\n    expr::{Expr, SequenceExpr},\n    linting::{ExprLinter, LintKind, Suggestion,"
  },
  {
    "path": "harper-core/src/linting/by_accident.rs",
    "chars": 4190,
    "preview": "/*\nlet message \"Did you mean `by accident`?\"\nlet description \"Incorrect preposition: `by accident` is the idiomatic expr"
  },
  {
    "path": "harper-core/src/linting/call_them.rs",
    "chars": 10929,
    "preview": "use std::{ops::Range, sync::Arc};\n\nuse crate::expr::{Expr, ExprMap, SequenceExpr};\nuse crate::patterns::DerivedFrom;\nuse"
  },
  {
    "path": "harper-core/src/linting/cant.rs",
    "chars": 3963,
    "preview": "use super::{ExprLinter, Suggestion};\nuse crate::Lint;\nuse crate::expr::{Expr, LongestMatchOf, SequenceExpr};\nuse crate::"
  },
  {
    "path": "harper-core/src/linting/capitalize_personal_pronouns.rs",
    "chars": 4738,
    "preview": "use crate::TokenStringExt;\n\nuse super::{Lint, LintKind, Linter, Suggestion};\n\n/// A linter that makes sure you capitaliz"
  },
  {
    "path": "harper-core/src/linting/cautionary_tale.rs",
    "chars": 4657,
    "preview": "use crate::linting::expr_linter::Chunk;\nuse crate::{\n    Token,\n    expr::{Expr, SequenceExpr},\n    linting::{ExprLinter"
  }
]

// ... and 1134 more files (download for full content)