├── .gitignore ├── release.toml ├── tests └── testsuite │ ├── main.rs │ └── codegen.rs ├── _typos.toml ├── .cargo └── config.toml ├── committed.toml ├── src ├── lib.rs ├── checker.rs └── wordlist_codegen.rs ├── .github ├── workflows │ ├── spelling.yml │ ├── pre-commit.yml │ ├── committed.yml │ ├── audit.yml │ ├── rust-next.yml │ └── ci.yml ├── settings.yml └── renovate.json5 ├── .pre-commit-config.yaml ├── .clippy.toml ├── LICENSE-MIT ├── CHANGELOG.md ├── README.md ├── assets ├── imperatives_blacklist.txt └── imperatives.txt ├── CONTRIBUTING.md ├── Cargo.toml ├── deny.toml ├── LICENSE-APACHE └── Cargo.lock /.gitignore: -------------------------------------------------------------------------------- 1 | target 2 | -------------------------------------------------------------------------------- /release.toml: -------------------------------------------------------------------------------- 1 | allow-branch = ["master"] 2 | -------------------------------------------------------------------------------- /tests/testsuite/main.rs: -------------------------------------------------------------------------------- 1 | automod::dir!("tests/testsuite"); 2 | -------------------------------------------------------------------------------- /_typos.toml: -------------------------------------------------------------------------------- 1 | [files] 2 | extend-exclude = [ 3 | "*codegen*", 4 | ] 5 | -------------------------------------------------------------------------------- /.cargo/config.toml: -------------------------------------------------------------------------------- 1 | [resolver] 2 | incompatible-rust-versions = "fallback" 3 | -------------------------------------------------------------------------------- /committed.toml: -------------------------------------------------------------------------------- 1 | style="conventional" 2 | ignore_author_re="(dependabot|renovate)" 3 | merge_commit = false 4 | -------------------------------------------------------------------------------- /src/lib.rs: -------------------------------------------------------------------------------- 1 | //! > DESCRIPTION 2 | 3 | #![cfg_attr(docsrs, feature(doc_cfg))] 4 | #![warn(clippy::print_stderr)] 5 | #![warn(clippy::print_stdout)] 6 | 7 | #[doc = include_str!("../README.md")] 8 | #[cfg(doctest)] 9 | pub struct ReadmeDoctests; 10 | 11 | mod checker; 12 | mod wordlist_codegen; 13 | 14 | pub use checker::*; 15 | -------------------------------------------------------------------------------- /.github/workflows/spelling.yml: -------------------------------------------------------------------------------- 1 | name: Spelling 2 | 3 | permissions: 4 | contents: read 5 | 6 | on: [pull_request] 7 | 8 | env: 9 | RUST_BACKTRACE: 1 10 | CARGO_TERM_COLOR: always 11 | CLICOLOR: 1 12 | 13 | concurrency: 14 | group: "${{ github.workflow }}-${{ github.ref }}" 15 | cancel-in-progress: true 16 | 17 | jobs: 18 | spelling: 19 | name: Spell Check with Typos 20 | runs-on: ubuntu-latest 21 | steps: 22 | - name: Checkout Actions Repository 23 | uses: actions/checkout@v6 24 | - name: Spell Check Repo 25 | uses: crate-ci/typos@master 26 | -------------------------------------------------------------------------------- /.pre-commit-config.yaml: -------------------------------------------------------------------------------- 1 | exclude: '^.*codegen.*' 2 | default_install_hook_types: ["pre-commit", "commit-msg"] 3 | repos: 4 | - repo: https://github.com/pre-commit/pre-commit-hooks 5 | rev: v5.0.0 6 | hooks: 7 | - id: check-yaml 8 | - id: check-json 9 | - id: check-toml 10 | - id: check-merge-conflict 11 | - id: check-case-conflict 12 | - id: detect-private-key 13 | - repo: https://github.com/crate-ci/typos 14 | rev: v1.32.0 15 | hooks: 16 | - id: typos 17 | - repo: https://github.com/crate-ci/committed 18 | rev: v1.1.7 19 | hooks: 20 | - id: committed 21 | -------------------------------------------------------------------------------- /.github/workflows/pre-commit.yml: -------------------------------------------------------------------------------- 1 | name: pre-commit 2 | 3 | permissions: {} # none 4 | 5 | on: 6 | pull_request: 7 | push: 8 | branches: [master] 9 | 10 | env: 11 | RUST_BACKTRACE: 1 12 | CARGO_TERM_COLOR: always 13 | CLICOLOR: 1 14 | 15 | concurrency: 16 | group: "${{ github.workflow }}-${{ github.ref }}" 17 | cancel-in-progress: true 18 | 19 | jobs: 20 | pre-commit: 21 | permissions: 22 | contents: read 23 | runs-on: ubuntu-latest 24 | steps: 25 | - uses: actions/checkout@v6 26 | - uses: actions/setup-python@v6 27 | with: 28 | python-version: '3.x' 29 | - uses: pre-commit/action@v3.0.1 30 | -------------------------------------------------------------------------------- /.github/workflows/committed.yml: -------------------------------------------------------------------------------- 1 | # Not run as part of pre-commit checks because they don't handle sending the correct commit 2 | # range to `committed` 3 | name: Lint Commits 4 | on: [pull_request] 5 | 6 | permissions: 7 | contents: read 8 | 9 | env: 10 | RUST_BACKTRACE: 1 11 | CARGO_TERM_COLOR: always 12 | CLICOLOR: 1 13 | 14 | concurrency: 15 | group: "${{ github.workflow }}-${{ github.ref }}" 16 | cancel-in-progress: true 17 | 18 | jobs: 19 | committed: 20 | name: Lint Commits 21 | runs-on: ubuntu-latest 22 | steps: 23 | - name: Checkout Actions Repository 24 | uses: actions/checkout@v6 25 | with: 26 | fetch-depth: 0 27 | - name: Lint Commits 28 | uses: crate-ci/committed@master 29 | -------------------------------------------------------------------------------- /.clippy.toml: -------------------------------------------------------------------------------- 1 | allow-print-in-tests = true 2 | allow-expect-in-tests = true 3 | allow-unwrap-in-tests = true 4 | allow-dbg-in-tests = true 5 | disallowed-methods = [ 6 | { path = "std::option::Option::map_or", reason = "prefer `map(..).unwrap_or(..)` for legibility" }, 7 | { path = "std::option::Option::map_or_else", reason = "prefer `map(..).unwrap_or_else(..)` for legibility" }, 8 | { path = "std::result::Result::map_or", reason = "prefer `map(..).unwrap_or(..)` for legibility" }, 9 | { path = "std::result::Result::map_or_else", reason = "prefer `map(..).unwrap_or_else(..)` for legibility" }, 10 | { path = "std::iter::Iterator::for_each", reason = "prefer `for` for side-effects" }, 11 | { path = "std::iter::Iterator::try_for_each", reason = "prefer `for` for side-effects" }, 12 | ] 13 | -------------------------------------------------------------------------------- /LICENSE-MIT: -------------------------------------------------------------------------------- 1 | Copyright (c) Individual contributors 2 | Copyright (c) 2012 GreenSteam, 3 | Copyright (c) 2014-2017 Amir Rachum, 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | -------------------------------------------------------------------------------- /CHANGELOG.md: -------------------------------------------------------------------------------- 1 | # Change Log 2 | All notable changes to this project will be documented in this file. 3 | 4 | The format is based on [Keep a Changelog](https://keepachangelog.com/) 5 | and this project adheres to [Semantic Versioning](https://semver.org/). 6 | 7 | 8 | ## [Unreleased] - ReleaseDate 9 | 10 | ## [1.0.6] - 2024-07-25 11 | 12 | ### Compatibility 13 | 14 | - Update MSRV to 1.74 15 | 16 | ## [1.0.5] - 2023-08-07 17 | 18 | ### Fixes 19 | 20 | - Report mood for `package` 21 | - Correctly report `added` is not imperative 22 | 23 | ## [1.0.4] - 2023-01-19 24 | 25 | ### Internal Changes 26 | 27 | - Removed unsafe 28 | 29 | ## [1.0.3] - 2023-01-19 30 | 31 | ### Fixes 32 | 33 | - Remove debug println 34 | 35 | ## [1.0.2] - 2021-01-30 36 | 37 | ## [1.0.0] - 2019-09-08 38 | 39 | 40 | ## [1.0.0] - 2019-08-01 41 | 42 | 43 | [Unreleased]: https://github.com/crate-ci/imperative/compare/v1.0.6...HEAD 44 | [1.0.6]: https://github.com/crate-ci/imperative/compare/v1.0.5...v1.0.6 45 | [1.0.5]: https://github.com/crate-ci/imperative/compare/v1.0.4...v1.0.5 46 | [1.0.4]: https://github.com/crate-ci/imperative/compare/v1.0.3...v1.0.4 47 | [1.0.3]: https://github.com/crate-ci/imperative/compare/v1.0.2...v1.0.3 48 | [1.0.2]: https://github.com/crate-ci/imperative/compare/v1.0.1...v1.0.2 49 | [1.0.1]: https://github.com/crate-ci/imperative/compare/v1.0.0...v1.0.1 50 | -------------------------------------------------------------------------------- /.github/workflows/audit.yml: -------------------------------------------------------------------------------- 1 | name: Security audit 2 | 3 | permissions: 4 | contents: read 5 | 6 | on: 7 | pull_request: 8 | paths: 9 | - '**/Cargo.toml' 10 | - '**/Cargo.lock' 11 | push: 12 | branches: 13 | - master 14 | 15 | env: 16 | RUST_BACKTRACE: 1 17 | CARGO_TERM_COLOR: always 18 | CLICOLOR: 1 19 | 20 | concurrency: 21 | group: "${{ github.workflow }}-${{ github.ref }}" 22 | cancel-in-progress: true 23 | 24 | jobs: 25 | security_audit: 26 | permissions: 27 | issues: write # to create issues (actions-rs/audit-check) 28 | checks: write # to create check (actions-rs/audit-check) 29 | runs-on: ubuntu-latest 30 | # Prevent sudden announcement of a new advisory from failing ci: 31 | continue-on-error: true 32 | steps: 33 | - name: Checkout repository 34 | uses: actions/checkout@v6 35 | - uses: actions-rs/audit-check@v1 36 | with: 37 | token: ${{ secrets.GITHUB_TOKEN }} 38 | 39 | cargo_deny: 40 | permissions: 41 | issues: write # to create issues (actions-rs/audit-check) 42 | checks: write # to create check (actions-rs/audit-check) 43 | runs-on: ubuntu-latest 44 | strategy: 45 | matrix: 46 | checks: 47 | - bans licenses sources 48 | steps: 49 | - uses: actions/checkout@v6 50 | - uses: EmbarkStudios/cargo-deny-action@v2 51 | with: 52 | command: check ${{ matrix.checks }} 53 | rust-version: stable 54 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # imperative 2 | 3 | > **Check the mood of a word** 4 | 5 | [![codecov](https://codecov.io/gh/crate-ci/imperative/branch/master/graph/badge.svg)](https://codecov.io/gh/crate-ci/imperative) 6 | [![Documentation](https://img.shields.io/badge/docs-master-blue.svg)][Documentation] 7 | ![License](https://img.shields.io/crates/l/imperative.svg) 8 | [![Crates Status](https://img.shields.io/crates/v/imperative.svg)][Crates.io] 9 | 10 | 11 | ## [Contribute](CONTRIBUTING.md) 12 | 13 | ## Special Thanks 14 | 15 | Thank you to [pydocstyle](https://github.com/PyCQA/pydocstyle/) for the algorithm and data set. 16 | 17 | ### Regenerating the wordlist 18 | 19 | If you change `assets/imperatives.txt` or `assets/imperatives_blacklist.txt`, run 20 | 21 | ```bash 22 | env SNAPSHOTS=overwrite cargo test 23 | ``` 24 | to regenerate the `wordlist_codegen.rs` file while running tests. 25 | 26 | ## License 27 | 28 | Licensed under either of 29 | 30 | * Apache License, Version 2.0, ([LICENSE-APACHE](LICENSE-APACHE) or ) 31 | * MIT license ([LICENSE-MIT](LICENSE-MIT) or ) 32 | 33 | at your option. 34 | 35 | ### Contribution 36 | 37 | Unless you explicitly state otherwise, any contribution intentionally 38 | submitted for inclusion in the work by you, as defined in the Apache-2.0 39 | license, shall be dual-licensed as above, without any additional terms or 40 | conditions. 41 | 42 | [Crates.io]: https://crates.io/crates/imperative 43 | [Documentation]: https://docs.rs/imperative 44 | -------------------------------------------------------------------------------- /src/checker.rs: -------------------------------------------------------------------------------- 1 | pub struct Mood { 2 | en_stemmer: rust_stemmers::Stemmer, 3 | } 4 | 5 | impl Mood { 6 | pub fn new() -> Self { 7 | Self { 8 | en_stemmer: rust_stemmers::Stemmer::create(rust_stemmers::Algorithm::English), 9 | } 10 | } 11 | 12 | /// **Note:** that the input is expected to be all lowercase (if that is applicable). 13 | pub fn is_imperative(&self, word: &str) -> Option { 14 | if crate::wordlist_codegen::BLACKLIST.contains(word) { 15 | return Some(false); 16 | } 17 | 18 | let stem = match word { 19 | "added" => "add".into(), 20 | _ => self.en_stemmer.stem(word), 21 | }; 22 | let imperative_forms = crate::wordlist_codegen::IMPERATIVES.get(stem.as_ref())?; 23 | Some(imperative_forms.contains(word)) 24 | } 25 | } 26 | 27 | impl Clone for Mood { 28 | fn clone(&self) -> Self { 29 | Self::new() 30 | } 31 | } 32 | 33 | impl Default for Mood { 34 | fn default() -> Self { 35 | Self::new() 36 | } 37 | } 38 | 39 | #[cfg(test)] 40 | mod test { 41 | use super::*; 42 | 43 | #[test] 44 | fn is_imperative() { 45 | let mood = Mood::new(); 46 | let cases = &[ 47 | ("runs", Some(false)), 48 | ("run", Some(true)), 49 | ("returns", Some(false)), 50 | ("return", Some(true)), 51 | ("constructor", Some(false)), 52 | ("adds", Some(false)), 53 | ("add", Some(true)), 54 | ("added", Some(false)), 55 | ]; 56 | for (word, expected) in cases.iter() { 57 | println!("Checking {word}"); 58 | assert_eq!(mood.is_imperative(word), expected.clone()); 59 | } 60 | } 61 | } 62 | -------------------------------------------------------------------------------- /.github/settings.yml: -------------------------------------------------------------------------------- 1 | # These settings are synced to GitHub by https://probot.github.io/apps/settings/ 2 | 3 | repository: 4 | description: "Check the mood of a word" 5 | homepage: "docs.rs/imperative" 6 | topics: "rust" 7 | has_issues: true 8 | has_projects: false 9 | has_wiki: false 10 | has_downloads: true 11 | default_branch: master 12 | 13 | # Preference: people do clean commits 14 | allow_merge_commit: true 15 | # Backup in case we need to clean up commits 16 | allow_squash_merge: true 17 | # Not really needed 18 | allow_rebase_merge: false 19 | 20 | allow_auto_merge: true 21 | delete_branch_on_merge: true 22 | 23 | squash_merge_commit_title: "PR_TITLE" 24 | squash_merge_commit_message: "PR_BODY" 25 | merge_commit_message: "PR_BODY" 26 | 27 | labels: 28 | # Type 29 | - name: bug 30 | color: '#b60205' 31 | description: "Not as expected" 32 | - name: enhancement 33 | color: '#1d76db' 34 | description: "Improve the expected" 35 | # Flavor 36 | - name: question 37 | color: "#cc317c" 38 | description: "Uncertainty is involved" 39 | - name: breaking-change 40 | color: "#e99695" 41 | - name: good first issue 42 | color: '#c2e0c6' 43 | description: "Help wanted!" 44 | 45 | # This serves more as documentation. 46 | # Branch protection API was replaced by rulesets but settings isn't updated. 47 | # See https://github.com/repository-settings/app/issues/825 48 | # 49 | # branches: 50 | # - name: master 51 | # protection: 52 | # required_pull_request_reviews: null 53 | # required_conversation_resolution: true 54 | # required_status_checks: 55 | # # Required. Require branches to be up to date before merging. 56 | # strict: false 57 | # contexts: ["CI", "Spell Check with Typos"] 58 | # enforce_admins: false 59 | # restrictions: null 60 | -------------------------------------------------------------------------------- /assets/imperatives_blacklist.txt: -------------------------------------------------------------------------------- 1 | # Blacklisted imperative words 2 | # 3 | # These are words that, if they begin a docstring, are a good indicator that 4 | # the docstring is not written in an imperative voice. 5 | # 6 | # The words included in this list fall into a number of categories: 7 | # 8 | # - Starting with a noun/pronoun indicates that the docstring is a noun phrase 9 | # or a sentence but not in the imperative mood 10 | # - Adjectives are always followed by a noun, so same 11 | # - Particles are also followed by a noun 12 | # - Some adverbs don't really indicate an imperative sentence, for example 13 | # "importantly" or "currently". 14 | # - Some irregular verb forms that don't stem to the same string as the 15 | # imperative does (eg. 'does') 16 | a 17 | an 18 | the 19 | action 20 | always 21 | api 22 | base 23 | basic 24 | business 25 | calculation 26 | callback 27 | collection 28 | common 29 | constructor 30 | convenience 31 | convenient 32 | current 33 | currently 34 | custom 35 | data 36 | default 37 | deprecated 38 | description 39 | dict 40 | dictionary 41 | does 42 | dummy 43 | example 44 | factory 45 | false 46 | final 47 | formula 48 | function 49 | generic 50 | handler 51 | helper 52 | here 53 | hook 54 | implementation 55 | importantly 56 | internal 57 | it 58 | main 59 | method 60 | module 61 | new 62 | number 63 | optional 64 | placeholder 65 | reference 66 | result 67 | same 68 | schema 69 | setup 70 | should 71 | simple 72 | some 73 | special 74 | sql 75 | standard 76 | static 77 | string 78 | subclasses 79 | that 80 | these 81 | this 82 | true 83 | unique 84 | unit 85 | utility 86 | what 87 | wrapper 88 | 89 | 90 | # These are nouns, but often used in the context of functions that act as 91 | # objects; thus we do not blacklist these. 92 | # 93 | # context # as in context manager 94 | # decorator 95 | # class # as in class decorator 96 | # property 97 | # generator 98 | -------------------------------------------------------------------------------- /.github/workflows/rust-next.yml: -------------------------------------------------------------------------------- 1 | name: rust-next 2 | 3 | permissions: 4 | contents: read 5 | 6 | on: 7 | schedule: 8 | - cron: '9 9 9 * *' 9 | 10 | env: 11 | RUST_BACKTRACE: 1 12 | CARGO_TERM_COLOR: always 13 | CLICOLOR: 1 14 | 15 | concurrency: 16 | group: "${{ github.workflow }}-${{ github.ref }}" 17 | cancel-in-progress: true 18 | 19 | jobs: 20 | test: 21 | name: Test 22 | strategy: 23 | matrix: 24 | os: ["ubuntu-latest", "windows-latest", "macos-latest"] 25 | rust: ["stable", "beta"] 26 | include: 27 | - os: ubuntu-latest 28 | rust: "nightly" 29 | continue-on-error: ${{ matrix.rust != 'stable' }} 30 | runs-on: ${{ matrix.os }} 31 | env: 32 | # Reduce amount of data cached 33 | CARGO_PROFILE_DEV_DEBUG: line-tables-only 34 | steps: 35 | - name: Checkout repository 36 | uses: actions/checkout@v6 37 | - name: Install Rust 38 | uses: dtolnay/rust-toolchain@stable 39 | with: 40 | toolchain: ${{ matrix.rust }} 41 | components: rustfmt 42 | - uses: Swatinem/rust-cache@v2 43 | - uses: taiki-e/install-action@cargo-hack 44 | - name: Build 45 | run: cargo test --workspace --no-run 46 | - name: Test 47 | run: cargo hack test --each-feature --workspace 48 | latest: 49 | name: "Check latest dependencies" 50 | runs-on: ubuntu-latest 51 | steps: 52 | - name: Checkout repository 53 | uses: actions/checkout@v6 54 | - name: Install Rust 55 | uses: dtolnay/rust-toolchain@stable 56 | with: 57 | toolchain: stable 58 | components: rustfmt 59 | - uses: Swatinem/rust-cache@v2 60 | - uses: taiki-e/install-action@cargo-hack 61 | - name: Update dependencies 62 | run: cargo update 63 | - name: Build 64 | run: cargo test --workspace --no-run 65 | - name: Test 66 | run: cargo hack test --each-feature --workspace 67 | -------------------------------------------------------------------------------- /.github/renovate.json5: -------------------------------------------------------------------------------- 1 | { 2 | schedule: [ 3 | 'before 5am on the first day of the month', 4 | ], 5 | semanticCommits: 'enabled', 6 | commitMessageLowerCase: 'never', 7 | configMigration: true, 8 | dependencyDashboard: true, 9 | customManagers: [ 10 | { 11 | customType: 'regex', 12 | managerFilePatterns: [ 13 | '/^rust-toolchain\\.toml$/', 14 | '/Cargo.toml$/', 15 | '/clippy.toml$/', 16 | '/\\.clippy.toml$/', 17 | '/^\\.github/workflows/ci.yml$/', 18 | '/^\\.github/workflows/rust-next.yml$/', 19 | ], 20 | matchStrings: [ 21 | 'STABLE.*?(?\\d+\\.\\d+(\\.\\d+)?)', 22 | '(?\\d+\\.\\d+(\\.\\d+)?).*?STABLE', 23 | ], 24 | depNameTemplate: 'STABLE', 25 | packageNameTemplate: 'rust-lang/rust', 26 | datasourceTemplate: 'github-releases', 27 | }, 28 | ], 29 | packageRules: [ 30 | { 31 | commitMessageTopic: 'Rust Stable', 32 | matchManagers: [ 33 | 'custom.regex', 34 | ], 35 | matchDepNames: [ 36 | 'STABLE', 37 | ], 38 | extractVersion: '^(?\\d+\\.\\d+)', // Drop the patch version 39 | schedule: [ 40 | '* * * * *', 41 | ], 42 | automerge: true, 43 | }, 44 | // Goals: 45 | // - Keep version reqs low, ignoring compatible normal/build dependencies 46 | // - Take advantage of latest dev-dependencies 47 | // - Rollup safe upgrades to reduce CI runner load 48 | // - Help keep number of versions down by always using latest breaking change 49 | // - Have lockfile and manifest in-sync 50 | { 51 | matchManagers: [ 52 | 'cargo', 53 | ], 54 | matchDepTypes: [ 55 | 'build-dependencies', 56 | 'dependencies', 57 | ], 58 | matchCurrentVersion: '>=0.1.0', 59 | matchUpdateTypes: [ 60 | 'patch', 61 | ], 62 | enabled: false, 63 | }, 64 | { 65 | matchManagers: [ 66 | 'cargo', 67 | ], 68 | matchDepTypes: [ 69 | 'build-dependencies', 70 | 'dependencies', 71 | ], 72 | matchCurrentVersion: '>=1.0.0', 73 | matchUpdateTypes: [ 74 | 'minor', 75 | 'patch', 76 | ], 77 | enabled: false, 78 | }, 79 | { 80 | matchManagers: [ 81 | 'cargo', 82 | ], 83 | matchDepTypes: [ 84 | 'dev-dependencies', 85 | ], 86 | matchCurrentVersion: '>=0.1.0', 87 | matchUpdateTypes: [ 88 | 'patch', 89 | ], 90 | automerge: true, 91 | groupName: 'compatible (dev)', 92 | }, 93 | { 94 | matchManagers: [ 95 | 'cargo', 96 | ], 97 | matchDepTypes: [ 98 | 'dev-dependencies', 99 | ], 100 | matchCurrentVersion: '>=1.0.0', 101 | matchUpdateTypes: [ 102 | 'minor', 103 | 'patch', 104 | ], 105 | automerge: true, 106 | groupName: 'compatible (dev)', 107 | }, 108 | ], 109 | } 110 | -------------------------------------------------------------------------------- /assets/imperatives.txt: -------------------------------------------------------------------------------- 1 | # Imperative forms of verbs 2 | # 3 | # This file contains the imperative form of frequently encountered 4 | # docstring verbs. Some of these may be more commonly encountered as 5 | # nouns, but blacklisting them for this may cause false positives. 6 | accept 7 | access 8 | add 9 | adjust 10 | aggregate 11 | allow 12 | append 13 | apply 14 | archive 15 | assert 16 | assign 17 | attempt 18 | authenticate 19 | authorize 20 | break 21 | build 22 | cache 23 | calculate 24 | call 25 | cancel 26 | capture 27 | change 28 | check 29 | clean 30 | clear 31 | close 32 | collect 33 | combine 34 | commit 35 | compare 36 | compute 37 | configure 38 | confirm 39 | connect 40 | construct 41 | control 42 | convert 43 | copy 44 | count 45 | create 46 | customize 47 | declare 48 | decode 49 | decorate 50 | define 51 | delegate 52 | delete 53 | deprecate 54 | derive 55 | describe 56 | detect 57 | determine 58 | display 59 | download 60 | drop 61 | dump 62 | emit 63 | empty 64 | enable 65 | encapsulate 66 | encode 67 | end 68 | ensure 69 | enumerate 70 | establish 71 | evaluate 72 | examine 73 | execute 74 | exit 75 | expand 76 | expect 77 | export 78 | extend 79 | extract 80 | feed 81 | fetch 82 | fill 83 | filter 84 | finalize 85 | find 86 | fire 87 | fix 88 | flag 89 | force 90 | format 91 | forward 92 | generate 93 | get 94 | give 95 | go 96 | group 97 | handle 98 | help 99 | hold 100 | identify 101 | implement 102 | import 103 | indicate 104 | init 105 | initialise 106 | initialize 107 | initiate 108 | input 109 | insert 110 | instantiate 111 | intercept 112 | invoke 113 | iterate 114 | join 115 | keep 116 | launch 117 | list 118 | listen 119 | load 120 | log 121 | look 122 | make 123 | manage 124 | manipulate 125 | map 126 | mark 127 | match 128 | merge 129 | mock 130 | modify 131 | monitor 132 | move 133 | normalize 134 | note 135 | obtain 136 | open 137 | output 138 | override 139 | overwrite 140 | package 141 | pad 142 | parse 143 | partial 144 | pass 145 | perform 146 | persist 147 | pick 148 | plot 149 | poll 150 | populate 151 | post 152 | prepare 153 | print 154 | process 155 | produce 156 | provide 157 | publish 158 | pull 159 | put 160 | query 161 | raise 162 | read 163 | record 164 | refer 165 | refresh 166 | register 167 | reload 168 | remove 169 | rename 170 | render 171 | replace 172 | reply 173 | report 174 | represent 175 | request 176 | require 177 | reset 178 | resolve 179 | retrieve 180 | return 181 | roll 182 | rollback 183 | round 184 | run 185 | sample 186 | save 187 | scan 188 | search 189 | select 190 | send 191 | serialise 192 | serialize 193 | serve 194 | set 195 | show 196 | simulate 197 | source 198 | specify 199 | split 200 | start 201 | step 202 | stop 203 | store 204 | strip 205 | submit 206 | subscribe 207 | sum 208 | swap 209 | sync 210 | synchronise 211 | synchronize 212 | take 213 | tear 214 | test 215 | time 216 | transform 217 | translate 218 | transmit 219 | truncate 220 | try 221 | turn 222 | tweak 223 | update 224 | upload 225 | use 226 | validate 227 | verify 228 | view 229 | wait 230 | walk 231 | wrap 232 | write 233 | yield 234 | -------------------------------------------------------------------------------- /tests/testsuite/codegen.rs: -------------------------------------------------------------------------------- 1 | pub(crate) const VERBS: &str = include_str!("../../assets/imperatives.txt"); 2 | pub(crate) const BLACKLIST: &str = include_str!("../../assets/imperatives_blacklist.txt"); 3 | 4 | #[test] 5 | fn codegen() { 6 | let mut content = vec![]; 7 | generate(&mut content); 8 | 9 | let content = String::from_utf8(content).unwrap(); 10 | let content = codegenrs::rustfmt(content, None).unwrap(); 11 | snapbox::assert_data_eq!( 12 | content, 13 | snapbox::file!["../../src/wordlist_codegen.rs"].raw() 14 | ); 15 | } 16 | 17 | fn generate(file: &mut W) { 18 | writeln!( 19 | file, 20 | "// This file is @generated by {}", 21 | file!().replace('\\', "/") 22 | ) 23 | .unwrap(); 24 | writeln!(file).unwrap(); 25 | 26 | let en_stemmer = rust_stemmers::Stemmer::create(rust_stemmers::Algorithm::English); 27 | let words: multimap::MultiMap<_, _> = parse_wordlist(VERBS) 28 | .map(|s| (en_stemmer.stem(s).into_owned(), s)) 29 | .collect(); 30 | 31 | let mut sorted_words: Vec<_> = words.iter_all().collect(); 32 | sorted_words.sort_unstable(); 33 | let sorted_words = sorted_words; 34 | for (stem, words) in sorted_words { 35 | let mut words = words.clone(); 36 | words.sort_unstable(); 37 | let words = words; 38 | writeln!( 39 | file, 40 | "pub(crate) static {}_STEM: phf::Set<&'static str> = ", 41 | stem.to_uppercase(), 42 | ) 43 | .unwrap(); 44 | let mut builder = phf_codegen::Set::new(); 45 | for word in words { 46 | builder.entry(word); 47 | } 48 | let codegenned = builder.build(); 49 | writeln!(file, "{codegenned}").unwrap(); 50 | writeln!(file, ";").unwrap(); 51 | writeln!(file).unwrap(); 52 | } 53 | 54 | let mut stems: Vec<_> = words.keys().collect(); 55 | stems.sort_unstable(); 56 | let stems = stems; 57 | let formatted_stems = stems 58 | .into_iter() 59 | .map(|stem| { 60 | let value = format!("&{stem}_stem").to_uppercase(); 61 | (stem, value) 62 | }) 63 | .collect::>(); 64 | writeln!( 65 | file, 66 | "pub(crate) static IMPERATIVES: phf::Map<&'static str, &phf::Set<&'static str>> = " 67 | ) 68 | .unwrap(); 69 | let mut builder = phf_codegen::Map::new(); 70 | for (stem, value) in &formatted_stems { 71 | builder.entry(stem.as_str(), value); 72 | } 73 | let codegenned = builder.build(); 74 | writeln!(file, "{codegenned}").unwrap(); 75 | writeln!(file, ";").unwrap(); 76 | 77 | let mut blacklist: Vec<_> = parse_wordlist(BLACKLIST).collect(); 78 | blacklist.sort_unstable(); 79 | let blacklist = blacklist; 80 | writeln!( 81 | file, 82 | "pub(crate) static BLACKLIST: phf::Set<&'static str> = " 83 | ) 84 | .unwrap(); 85 | let mut builder = phf_codegen::Set::new(); 86 | for word in blacklist { 87 | builder.entry(word); 88 | } 89 | let codegenned = builder.build(); 90 | writeln!(file, "{codegenned}").unwrap(); 91 | writeln!(file, ";").unwrap(); 92 | } 93 | 94 | fn parse_wordlist(raw: &str) -> impl Iterator { 95 | raw.lines() 96 | .map(|s| s.split('#').next().expect("always at least one").trim()) 97 | .filter(|s| !s.is_empty()) 98 | } 99 | -------------------------------------------------------------------------------- /CONTRIBUTING.md: -------------------------------------------------------------------------------- 1 | # Contributing to `imperative` 2 | 3 | Thanks for wanting to contribute! There are many ways to contribute and we 4 | appreciate any level you're willing to do. 5 | 6 | ## Feature Requests 7 | 8 | Need some new functionality to help? You can let us know by opening an 9 | [issue][new issue]. It's helpful to look through [all issues][all issues] in 10 | case it's already being talked about. 11 | 12 | ## Bug Reports 13 | 14 | Please let us know about what problems you run into, whether in behavior or 15 | ergonomics of API. You can do this by opening an [issue][new issue]. It's 16 | helpful to look through [all issues][all issues] in case it's already being 17 | talked about. 18 | 19 | ## Pull Requests 20 | 21 | Looking for an idea? Check our [issues][issues]. If the issue looks open ended, 22 | it is probably best to post on the issue how you are thinking of resolving the 23 | issue so you can get feedback early in the process. We want you to be 24 | successful and it can be discouraging to find out a lot of re-work is needed. 25 | 26 | Already have an idea? It might be good to first [create an issue][new issue] 27 | to propose it so we can make sure we are aligned and lower the risk of having 28 | to re-work some of it and the discouragement that goes along with that. 29 | 30 | ### Process 31 | 32 | As a heads up, we'll be running your PR through the following gauntlet: 33 | - warnings turned to compile errors 34 | - `cargo test` 35 | - `rustfmt` 36 | - `clippy` 37 | - `rustdoc` 38 | - [`committed`](https://github.com/crate-ci/committed) as we use [Conventional](https://www.conventionalcommits.org) commit style 39 | - [`typos`](https://github.com/crate-ci/typos) to check spelling 40 | 41 | Not everything can be checked automatically though. 42 | 43 | We request that the commit history gets cleaned up. 44 | 45 | We ask that commits are atomic, meaning they are complete and have a single responsibility. 46 | A complete commit should build, pass tests, update documentation and tests, and not have dead code. 47 | 48 | PRs should tell a cohesive story, with refactor and test commits that keep the 49 | fix or feature commits simple and clear. 50 | 51 | Specifically, we would encourage 52 | - File renames be isolated into their own commit 53 | - Add tests in a commit before their feature or fix, showing the current behavior (i.e. they should pass). 54 | The diff for the feature/fix commit will then show how the behavior changed, 55 | making the commit's intent clearer to reviewers and the community, and showing people that the 56 | test is verifying the expected state. 57 | - e.g. [clap#5520](https://github.com/clap-rs/clap/pull/5520) 58 | 59 | Note that we are talking about ideals. 60 | We understand having a clean history requires more advanced git skills; 61 | feel free to ask us for help! 62 | We might even suggest where it would work to be lax. 63 | We also understand that editing some early commits may cause a lot of churn 64 | with merge conflicts which can make it not worth editing all of the history. 65 | 66 | For code organization, we recommend 67 | - Grouping `impl` blocks next to their type (or trait) 68 | - Grouping private items after the `pub` item that uses them. 69 | - The intent is to help people quickly find the "relevant" details, allowing them to "dig deeper" as needed. Or put another way, the `pub` items serve as a table-of-contents. 70 | - The exact order is fuzzy; do what makes sense 71 | 72 | ## Releasing 73 | 74 | Pre-requisites 75 | - Running `cargo login` 76 | - A member of `ORG:Maintainers` 77 | - Push permission to the repo 78 | - [`cargo-release`](https://github.com/crate-ci/cargo-release/) 79 | 80 | When we're ready to release, a project owner should do the following 81 | 1. Update the changelog (see `cargo release changes` for ideas) 82 | 2. Determine what the next version is, according to semver 83 | 3. Run [`cargo release -x `](https://github.com/crate-ci/cargo-release) 84 | 85 | [issues]: https://github.com/crate-ci/imperative/issues 86 | [new issue]: https://github.com/crate-ci/imperative/issues/new 87 | [all issues]: https://github.com/crate-ci/imperative/issues?utf8=%E2%9C%93&q=is%3Aissue 88 | -------------------------------------------------------------------------------- /Cargo.toml: -------------------------------------------------------------------------------- 1 | [workspace] 2 | resolver = "2" 3 | 4 | [workspace.package] 5 | repository = "https://github.com/crate-ci/imperative" 6 | license = "MIT OR Apache-2.0" 7 | edition = "2021" 8 | rust-version = "1.74" # MSRV 9 | include = [ 10 | "build.rs", 11 | "src/**/*", 12 | "Cargo.toml", 13 | "Cargo.lock", 14 | "LICENSE*", 15 | "README.md", 16 | "examples/**/*" 17 | ] 18 | 19 | [workspace.lints.rust] 20 | rust_2018_idioms = { level = "warn", priority = -1 } 21 | unnameable_types = "warn" 22 | unreachable_pub = "warn" 23 | unsafe_op_in_unsafe_fn = "warn" 24 | unused_lifetimes = "warn" 25 | unused_macro_rules = "warn" 26 | unused_qualifications = "warn" 27 | 28 | [workspace.lints.clippy] 29 | bool_assert_comparison = "allow" 30 | branches_sharing_code = "allow" 31 | checked_conversions = "warn" 32 | collapsible_else_if = "allow" 33 | create_dir = "warn" 34 | dbg_macro = "warn" 35 | debug_assert_with_mut_call = "warn" 36 | doc_markdown = "warn" 37 | empty_enum = "warn" 38 | enum_glob_use = "warn" 39 | expl_impl_clone_on_copy = "warn" 40 | explicit_deref_methods = "warn" 41 | explicit_into_iter_loop = "warn" 42 | fallible_impl_from = "warn" 43 | filter_map_next = "warn" 44 | flat_map_option = "warn" 45 | float_cmp_const = "warn" 46 | fn_params_excessive_bools = "warn" 47 | from_iter_instead_of_collect = "warn" 48 | if_same_then_else = "allow" 49 | implicit_clone = "warn" 50 | imprecise_flops = "warn" 51 | inconsistent_struct_constructor = "warn" 52 | inefficient_to_string = "warn" 53 | infinite_loop = "warn" 54 | invalid_upcast_comparisons = "warn" 55 | large_digit_groups = "warn" 56 | large_stack_arrays = "warn" 57 | large_types_passed_by_value = "warn" 58 | let_and_return = "allow" # sometimes good to name what you are returning 59 | linkedlist = "warn" 60 | lossy_float_literal = "warn" 61 | macro_use_imports = "warn" 62 | mem_forget = "warn" 63 | mutex_integer = "warn" 64 | needless_continue = "allow" 65 | needless_for_each = "warn" 66 | negative_feature_names = "warn" 67 | path_buf_push_overwrite = "warn" 68 | ptr_as_ptr = "warn" 69 | rc_mutex = "warn" 70 | redundant_feature_names = "warn" 71 | ref_option_ref = "warn" 72 | rest_pat_in_fully_bound_structs = "warn" 73 | result_large_err = "allow" 74 | same_functions_in_if_condition = "warn" 75 | self_named_module_files = "warn" 76 | semicolon_if_nothing_returned = "warn" 77 | str_to_string = "warn" 78 | string_add = "warn" 79 | string_add_assign = "warn" 80 | string_lit_as_bytes = "warn" 81 | string_to_string = "warn" 82 | todo = "warn" 83 | trait_duplication_in_bounds = "warn" 84 | uninlined_format_args = "warn" 85 | verbose_file_reads = "warn" 86 | wildcard_imports = "warn" 87 | zero_sized_map_values = "warn" 88 | 89 | [profile.dev] 90 | panic = "abort" 91 | 92 | [profile.release] 93 | panic = "abort" 94 | codegen-units = 1 95 | lto = true 96 | # debug = "line-tables-only" # requires Cargo 1.71 97 | 98 | [package] 99 | name = "imperative" 100 | version = "1.0.6" 101 | description = "Check for imperative mood in text" 102 | authors = ["Ed Page "] 103 | documentation = "https://docs.rs/imperative" 104 | readme = "README.md" 105 | categories = ["text-processing"] 106 | repository.workspace = true 107 | license.workspace = true 108 | edition.workspace = true 109 | rust-version.workspace = true 110 | include.workspace = true 111 | 112 | [package.metadata.docs.rs] 113 | all-features = true 114 | rustdoc-args = ["--generate-link-to-definition"] 115 | 116 | [package.metadata.release] 117 | pre-release-replacements = [ 118 | {file="CHANGELOG.md", search="Unreleased", replace="{{version}}", min=1}, 119 | {file="CHANGELOG.md", search="\\.\\.\\.HEAD", replace="...{{tag_name}}", exactly=1}, 120 | {file="CHANGELOG.md", search="ReleaseDate", replace="{{date}}", min=1}, 121 | {file="CHANGELOG.md", search="", replace="\n## [Unreleased] - ReleaseDate\n", exactly=1}, 122 | {file="CHANGELOG.md", search="", replace="\n[Unreleased]: https://github.com/crate-ci/imperative/compare/{{tag_name}}...HEAD", exactly=1}, 123 | ] 124 | 125 | [dependencies] 126 | rust-stemmers = "1.2.0" 127 | phf = "0.13" 128 | 129 | [dev-dependencies] 130 | snapbox = "0.6.21" 131 | phf_codegen = "0.13" 132 | rust-stemmers = "1.2.0" 133 | multimap = "0.10.1" 134 | codegenrs = "3.0" 135 | automod = "1.0.15" 136 | 137 | [lints] 138 | workspace = true 139 | -------------------------------------------------------------------------------- /.github/workflows/ci.yml: -------------------------------------------------------------------------------- 1 | name: CI 2 | 3 | permissions: 4 | contents: read 5 | 6 | on: 7 | pull_request: 8 | push: 9 | branches: 10 | - master 11 | 12 | env: 13 | RUST_BACKTRACE: 1 14 | CARGO_TERM_COLOR: always 15 | CLICOLOR: 1 16 | 17 | concurrency: 18 | group: "${{ github.workflow }}-${{ github.ref }}" 19 | cancel-in-progress: true 20 | 21 | jobs: 22 | ci: 23 | permissions: 24 | contents: none 25 | name: CI 26 | needs: [test, msrv, lockfile, docs, rustfmt, clippy, minimal-versions] 27 | runs-on: ubuntu-latest 28 | if: "always()" 29 | steps: 30 | - name: Failed 31 | run: exit 1 32 | if: "contains(needs.*.result, 'failure') || contains(needs.*.result, 'cancelled') || contains(needs.*.result, 'skipped')" 33 | test: 34 | name: Test 35 | strategy: 36 | matrix: 37 | os: ["ubuntu-latest", "windows-latest", "macos-latest"] 38 | rust: ["stable"] 39 | continue-on-error: ${{ matrix.rust != 'stable' }} 40 | runs-on: ${{ matrix.os }} 41 | env: 42 | # Reduce amount of data cached 43 | CARGO_PROFILE_DEV_DEBUG: line-tables-only 44 | steps: 45 | - name: Checkout repository 46 | uses: actions/checkout@v6 47 | - name: Install Rust 48 | uses: dtolnay/rust-toolchain@stable 49 | with: 50 | toolchain: ${{ matrix.rust }} 51 | components: rustfmt 52 | - uses: Swatinem/rust-cache@v2 53 | - uses: taiki-e/install-action@cargo-hack 54 | - name: Build 55 | run: cargo test --workspace --no-run 56 | - name: Test 57 | run: cargo hack test --each-feature --workspace 58 | msrv: 59 | name: "Check MSRV" 60 | runs-on: ubuntu-latest 61 | steps: 62 | - name: Checkout repository 63 | uses: actions/checkout@v6 64 | - name: Install Rust 65 | uses: dtolnay/rust-toolchain@stable 66 | with: 67 | toolchain: stable 68 | - uses: Swatinem/rust-cache@v2 69 | - uses: taiki-e/install-action@cargo-hack 70 | - name: Default features 71 | run: cargo hack check --each-feature --locked --rust-version --ignore-private --workspace --all-targets --keep-going 72 | minimal-versions: 73 | name: Minimal versions 74 | runs-on: ubuntu-latest 75 | steps: 76 | - name: Checkout repository 77 | uses: actions/checkout@v6 78 | - name: Install stable Rust 79 | uses: dtolnay/rust-toolchain@stable 80 | with: 81 | toolchain: stable 82 | - name: Install nightly Rust 83 | uses: dtolnay/rust-toolchain@stable 84 | with: 85 | toolchain: nightly 86 | - name: Downgrade dependencies to minimal versions 87 | run: cargo +nightly generate-lockfile -Z minimal-versions 88 | - name: Compile with minimal versions 89 | run: cargo +stable check --workspace --all-features --locked --keep-going 90 | lockfile: 91 | runs-on: ubuntu-latest 92 | steps: 93 | - name: Checkout repository 94 | uses: actions/checkout@v6 95 | - name: Install Rust 96 | uses: dtolnay/rust-toolchain@stable 97 | with: 98 | toolchain: stable 99 | - uses: Swatinem/rust-cache@v2 100 | - name: "Is lockfile updated?" 101 | run: cargo update --workspace --locked 102 | docs: 103 | name: Docs 104 | runs-on: ubuntu-latest 105 | steps: 106 | - name: Checkout repository 107 | uses: actions/checkout@v6 108 | - name: Install Rust 109 | uses: dtolnay/rust-toolchain@stable 110 | with: 111 | toolchain: "1.92" # STABLE 112 | - uses: Swatinem/rust-cache@v2 113 | - name: Check documentation 114 | env: 115 | RUSTDOCFLAGS: -D warnings 116 | run: cargo doc --workspace --all-features --no-deps --document-private-items --keep-going 117 | rustfmt: 118 | name: rustfmt 119 | runs-on: ubuntu-latest 120 | steps: 121 | - name: Checkout repository 122 | uses: actions/checkout@v6 123 | - name: Install Rust 124 | uses: dtolnay/rust-toolchain@stable 125 | with: 126 | toolchain: "1.92" # STABLE 127 | components: rustfmt 128 | - uses: Swatinem/rust-cache@v2 129 | - name: Check formatting 130 | run: cargo fmt --all -- --check 131 | clippy: 132 | name: clippy 133 | runs-on: ubuntu-latest 134 | permissions: 135 | security-events: write # to upload sarif results 136 | steps: 137 | - name: Checkout repository 138 | uses: actions/checkout@v6 139 | - name: Install Rust 140 | uses: dtolnay/rust-toolchain@stable 141 | with: 142 | toolchain: "1.92" # STABLE 143 | components: clippy 144 | - uses: Swatinem/rust-cache@v2 145 | - name: Install SARIF tools 146 | run: cargo install clippy-sarif --locked 147 | - name: Install SARIF tools 148 | run: cargo install sarif-fmt --locked 149 | - name: Check 150 | run: > 151 | cargo clippy --workspace --all-features --all-targets --message-format=json 152 | | clippy-sarif 153 | | tee clippy-results.sarif 154 | | sarif-fmt 155 | continue-on-error: true 156 | - name: Upload 157 | uses: github/codeql-action/upload-sarif@v4 158 | with: 159 | sarif_file: clippy-results.sarif 160 | wait-for-processing: true 161 | - name: Report status 162 | run: cargo clippy --workspace --all-features --all-targets --keep-going -- -D warnings --allow deprecated 163 | coverage: 164 | name: Coverage 165 | runs-on: ubuntu-latest 166 | steps: 167 | - name: Checkout repository 168 | uses: actions/checkout@v6 169 | - name: Install Rust 170 | uses: dtolnay/rust-toolchain@stable 171 | with: 172 | toolchain: stable 173 | - uses: Swatinem/rust-cache@v2 174 | - name: Install cargo-tarpaulin 175 | run: cargo install cargo-tarpaulin 176 | - name: Gather coverage 177 | run: cargo tarpaulin --output-dir coverage --out lcov 178 | - name: Publish to Coveralls 179 | uses: coverallsapp/github-action@master 180 | with: 181 | github-token: ${{ secrets.GITHUB_TOKEN }} 182 | -------------------------------------------------------------------------------- /deny.toml: -------------------------------------------------------------------------------- 1 | # Note that all fields that take a lint level have these possible values: 2 | # * deny - An error will be produced and the check will fail 3 | # * warn - A warning will be produced, but the check will not fail 4 | # * allow - No warning or error will be produced, though in some cases a note 5 | # will be 6 | 7 | # Root options 8 | 9 | # The graph table configures how the dependency graph is constructed and thus 10 | # which crates the checks are performed against 11 | [graph] 12 | # If 1 or more target triples (and optionally, target_features) are specified, 13 | # only the specified targets will be checked when running `cargo deny check`. 14 | # This means, if a particular package is only ever used as a target specific 15 | # dependency, such as, for example, the `nix` crate only being used via the 16 | # `target_family = "unix"` configuration, that only having windows targets in 17 | # this list would mean the nix crate, as well as any of its exclusive 18 | # dependencies not shared by any other crates, would be ignored, as the target 19 | # list here is effectively saying which targets you are building for. 20 | targets = [ 21 | # The triple can be any string, but only the target triples built in to 22 | # rustc (as of 1.40) can be checked against actual config expressions 23 | #"x86_64-unknown-linux-musl", 24 | # You can also specify which target_features you promise are enabled for a 25 | # particular target. target_features are currently not validated against 26 | # the actual valid features supported by the target architecture. 27 | #{ triple = "wasm32-unknown-unknown", features = ["atomics"] }, 28 | ] 29 | # When creating the dependency graph used as the source of truth when checks are 30 | # executed, this field can be used to prune crates from the graph, removing them 31 | # from the view of cargo-deny. This is an extremely heavy hammer, as if a crate 32 | # is pruned from the graph, all of its dependencies will also be pruned unless 33 | # they are connected to another crate in the graph that hasn't been pruned, 34 | # so it should be used with care. The identifiers are [Package ID Specifications] 35 | # (https://doc.rust-lang.org/cargo/reference/pkgid-spec.html) 36 | #exclude = [] 37 | # If true, metadata will be collected with `--all-features`. Note that this can't 38 | # be toggled off if true, if you want to conditionally enable `--all-features` it 39 | # is recommended to pass `--all-features` on the cmd line instead 40 | all-features = false 41 | # If true, metadata will be collected with `--no-default-features`. The same 42 | # caveat with `all-features` applies 43 | no-default-features = false 44 | # If set, these feature will be enabled when collecting metadata. If `--features` 45 | # is specified on the cmd line they will take precedence over this option. 46 | #features = [] 47 | 48 | # The output table provides options for how/if diagnostics are outputted 49 | [output] 50 | # When outputting inclusion graphs in diagnostics that include features, this 51 | # option can be used to specify the depth at which feature edges will be added. 52 | # This option is included since the graphs can be quite large and the addition 53 | # of features from the crate(s) to all of the graph roots can be far too verbose. 54 | # This option can be overridden via `--feature-depth` on the cmd line 55 | feature-depth = 1 56 | 57 | # This section is considered when running `cargo deny check advisories` 58 | # More documentation for the advisories section can be found here: 59 | # https://embarkstudios.github.io/cargo-deny/checks/advisories/cfg.html 60 | [advisories] 61 | # The path where the advisory databases are cloned/fetched into 62 | #db-path = "$CARGO_HOME/advisory-dbs" 63 | # The url(s) of the advisory databases to use 64 | #db-urls = ["https://github.com/rustsec/advisory-db"] 65 | # A list of advisory IDs to ignore. Note that ignored advisories will still 66 | # output a note when they are encountered. 67 | ignore = [ 68 | #"RUSTSEC-0000-0000", 69 | #{ id = "RUSTSEC-0000-0000", reason = "you can specify a reason the advisory is ignored" }, 70 | #"a-crate-that-is-yanked@0.1.1", # you can also ignore yanked crate versions if you wish 71 | #{ crate = "a-crate-that-is-yanked@0.1.1", reason = "you can specify why you are ignoring the yanked crate" }, 72 | ] 73 | # If this is true, then cargo deny will use the git executable to fetch advisory database. 74 | # If this is false, then it uses a built-in git library. 75 | # Setting this to true can be helpful if you have special authentication requirements that cargo-deny does not support. 76 | # See Git Authentication for more information about setting up git authentication. 77 | #git-fetch-with-cli = true 78 | 79 | # This section is considered when running `cargo deny check licenses` 80 | # More documentation for the licenses section can be found here: 81 | # https://embarkstudios.github.io/cargo-deny/checks/licenses/cfg.html 82 | [licenses] 83 | # List of explicitly allowed licenses 84 | # See https://spdx.org/licenses/ for list of possible licenses 85 | # [possible values: any SPDX 3.11 short identifier (+ optional exception)]. 86 | allow = [ 87 | "MIT", 88 | "MIT-0", 89 | "Apache-2.0", 90 | "BSD-2-Clause", 91 | "BSD-3-Clause", 92 | "MPL-2.0", 93 | "Unicode-DFS-2016", 94 | "Unicode-3.0", 95 | "CC0-1.0", 96 | "ISC", 97 | "OpenSSL", 98 | "Zlib", 99 | "NCSA", 100 | ] 101 | # The confidence threshold for detecting a license from license text. 102 | # The higher the value, the more closely the license text must be to the 103 | # canonical license text of a valid SPDX license file. 104 | # [possible values: any between 0.0 and 1.0]. 105 | confidence-threshold = 0.8 106 | # Allow 1 or more licenses on a per-crate basis, so that particular licenses 107 | # aren't accepted for every possible crate as with the normal allow list 108 | exceptions = [ 109 | # Each entry is the crate and version constraint, and its specific allow 110 | # list 111 | #{ allow = ["Zlib"], crate = "adler32" }, 112 | ] 113 | 114 | # Some crates don't have (easily) machine readable licensing information, 115 | # adding a clarification entry for it allows you to manually specify the 116 | # licensing information 117 | [[licenses.clarify]] 118 | # The package spec the clarification applies to 119 | crate = "ring" 120 | # The SPDX expression for the license requirements of the crate 121 | expression = "MIT AND ISC AND OpenSSL" 122 | # One or more files in the crate's source used as the "source of truth" for 123 | # the license expression. If the contents match, the clarification will be used 124 | # when running the license check, otherwise the clarification will be ignored 125 | # and the crate will be checked normally, which may produce warnings or errors 126 | # depending on the rest of your configuration 127 | license-files = [ 128 | # Each entry is a crate relative path, and the (opaque) hash of its contents 129 | { path = "LICENSE", hash = 0xbd0eed23 } 130 | ] 131 | 132 | [licenses.private] 133 | # If true, ignores workspace crates that aren't published, or are only 134 | # published to private registries. 135 | # To see how to mark a crate as unpublished (to the official registry), 136 | # visit https://doc.rust-lang.org/cargo/reference/manifest.html#the-publish-field. 137 | ignore = true 138 | # One or more private registries that you might publish crates to, if a crate 139 | # is only published to private registries, and ignore is true, the crate will 140 | # not have its license(s) checked 141 | registries = [ 142 | #"https://sekretz.com/registry 143 | ] 144 | 145 | # This section is considered when running `cargo deny check bans`. 146 | # More documentation about the 'bans' section can be found here: 147 | # https://embarkstudios.github.io/cargo-deny/checks/bans/cfg.html 148 | [bans] 149 | # Lint level for when multiple versions of the same crate are detected 150 | multiple-versions = "warn" 151 | # Lint level for when a crate version requirement is `*` 152 | wildcards = "allow" 153 | # The graph highlighting used when creating dotgraphs for crates 154 | # with multiple versions 155 | # * lowest-version - The path to the lowest versioned duplicate is highlighted 156 | # * simplest-path - The path to the version with the fewest edges is highlighted 157 | # * all - Both lowest-version and simplest-path are used 158 | highlight = "all" 159 | # The default lint level for `default` features for crates that are members of 160 | # the workspace that is being checked. This can be overridden by allowing/denying 161 | # `default` on a crate-by-crate basis if desired. 162 | workspace-default-features = "allow" 163 | # The default lint level for `default` features for external crates that are not 164 | # members of the workspace. This can be overridden by allowing/denying `default` 165 | # on a crate-by-crate basis if desired. 166 | external-default-features = "allow" 167 | # List of crates that are allowed. Use with care! 168 | allow = [ 169 | #"ansi_term@0.11.0", 170 | #{ crate = "ansi_term@0.11.0", reason = "you can specify a reason it is allowed" }, 171 | ] 172 | # List of crates to deny 173 | deny = [ 174 | #"ansi_term@0.11.0", 175 | #{ crate = "ansi_term@0.11.0", reason = "you can specify a reason it is banned" }, 176 | # Wrapper crates can optionally be specified to allow the crate when it 177 | # is a direct dependency of the otherwise banned crate 178 | #{ crate = "ansi_term@0.11.0", wrappers = ["this-crate-directly-depends-on-ansi_term"] }, 179 | ] 180 | 181 | # List of features to allow/deny 182 | # Each entry the name of a crate and a version range. If version is 183 | # not specified, all versions will be matched. 184 | #[[bans.features]] 185 | #crate = "reqwest" 186 | # Features to not allow 187 | #deny = ["json"] 188 | # Features to allow 189 | #allow = [ 190 | # "rustls", 191 | # "__rustls", 192 | # "__tls", 193 | # "hyper-rustls", 194 | # "rustls", 195 | # "rustls-pemfile", 196 | # "rustls-tls-webpki-roots", 197 | # "tokio-rustls", 198 | # "webpki-roots", 199 | #] 200 | # If true, the allowed features must exactly match the enabled feature set. If 201 | # this is set there is no point setting `deny` 202 | #exact = true 203 | 204 | # Certain crates/versions that will be skipped when doing duplicate detection. 205 | skip = [ 206 | #"ansi_term@0.11.0", 207 | #{ crate = "ansi_term@0.11.0", reason = "you can specify a reason why it can't be updated/removed" }, 208 | ] 209 | # Similarly to `skip` allows you to skip certain crates during duplicate 210 | # detection. Unlike skip, it also includes the entire tree of transitive 211 | # dependencies starting at the specified crate, up to a certain depth, which is 212 | # by default infinite. 213 | skip-tree = [ 214 | #"ansi_term@0.11.0", # will be skipped along with _all_ of its direct and transitive dependencies 215 | #{ crate = "ansi_term@0.11.0", depth = 20 }, 216 | ] 217 | 218 | # This section is considered when running `cargo deny check sources`. 219 | # More documentation about the 'sources' section can be found here: 220 | # https://embarkstudios.github.io/cargo-deny/checks/sources/cfg.html 221 | [sources] 222 | # Lint level for what to happen when a crate from a crate registry that is not 223 | # in the allow list is encountered 224 | unknown-registry = "deny" 225 | # Lint level for what to happen when a crate from a git repository that is not 226 | # in the allow list is encountered 227 | unknown-git = "deny" 228 | # List of URLs for allowed crate registries. Defaults to the crates.io index 229 | # if not specified. If it is specified but empty, no registries are allowed. 230 | allow-registry = ["https://github.com/rust-lang/crates.io-index"] 231 | # List of URLs for allowed Git repositories 232 | allow-git = [] 233 | 234 | [sources.allow-org] 235 | # 1 or more github.com organizations to allow git sources for 236 | github = [] 237 | # 1 or more gitlab.com organizations to allow git sources for 238 | gitlab = [] 239 | # 1 or more bitbucket.org organizations to allow git sources for 240 | bitbucket = [] 241 | -------------------------------------------------------------------------------- /LICENSE-APACHE: -------------------------------------------------------------------------------- 1 | Apache License 2 | Version 2.0, January 2004 3 | http://www.apache.org/licenses/ 4 | 5 | TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION 6 | 7 | 1. Definitions. 8 | 9 | "License" shall mean the terms and conditions for use, reproduction, 10 | and distribution as defined by Sections 1 through 9 of this document. 11 | 12 | "Licensor" shall mean the copyright owner or entity authorized by 13 | the copyright owner that is granting the License. 14 | 15 | "Legal Entity" shall mean the union of the acting entity and all 16 | other entities that control, are controlled by, or are under common 17 | control with that entity. For the purposes of this definition, 18 | "control" means (i) the power, direct or indirect, to cause the 19 | direction or management of such entity, whether by contract or 20 | otherwise, or (ii) ownership of fifty percent (50%) or more of the 21 | outstanding shares, or (iii) beneficial ownership of such entity. 22 | 23 | "You" (or "Your") shall mean an individual or Legal Entity 24 | exercising permissions granted by this License. 25 | 26 | "Source" form shall mean the preferred form for making modifications, 27 | including but not limited to software source code, documentation 28 | source, and configuration files. 29 | 30 | "Object" form shall mean any form resulting from mechanical 31 | transformation or translation of a Source form, including but 32 | not limited to compiled object code, generated documentation, 33 | and conversions to other media types. 34 | 35 | "Work" shall mean the work of authorship, whether in Source or 36 | Object form, made available under the License, as indicated by a 37 | copyright notice that is included in or attached to the work 38 | (an example is provided in the Appendix below). 39 | 40 | "Derivative Works" shall mean any work, whether in Source or Object 41 | form, that is based on (or derived from) the Work and for which the 42 | editorial revisions, annotations, elaborations, or other modifications 43 | represent, as a whole, an original work of authorship. For the purposes 44 | of this License, Derivative Works shall not include works that remain 45 | separable from, or merely link (or bind by name) to the interfaces of, 46 | the Work and Derivative Works thereof. 47 | 48 | "Contribution" shall mean any work of authorship, including 49 | the original version of the Work and any modifications or additions 50 | to that Work or Derivative Works thereof, that is intentionally 51 | submitted to Licensor for inclusion in the Work by the copyright owner 52 | or by an individual or Legal Entity authorized to submit on behalf of 53 | the copyright owner. For the purposes of this definition, "submitted" 54 | means any form of electronic, verbal, or written communication sent 55 | to the Licensor or its representatives, including but not limited to 56 | communication on electronic mailing lists, source code control systems, 57 | and issue tracking systems that are managed by, or on behalf of, the 58 | Licensor for the purpose of discussing and improving the Work, but 59 | excluding communication that is conspicuously marked or otherwise 60 | designated in writing by the copyright owner as "Not a Contribution." 61 | 62 | "Contributor" shall mean Licensor and any individual or Legal Entity 63 | on behalf of whom a Contribution has been received by Licensor and 64 | subsequently incorporated within the Work. 65 | 66 | 2. Grant of Copyright License. Subject to the terms and conditions of 67 | this License, each Contributor hereby grants to You a perpetual, 68 | worldwide, non-exclusive, no-charge, royalty-free, irrevocable 69 | copyright license to reproduce, prepare Derivative Works of, 70 | publicly display, publicly perform, sublicense, and distribute the 71 | Work and such Derivative Works in Source or Object form. 72 | 73 | 3. Grant of Patent License. Subject to the terms and conditions of 74 | this License, each Contributor hereby grants to You a perpetual, 75 | worldwide, non-exclusive, no-charge, royalty-free, irrevocable 76 | (except as stated in this section) patent license to make, have made, 77 | use, offer to sell, sell, import, and otherwise transfer the Work, 78 | where such license applies only to those patent claims licensable 79 | by such Contributor that are necessarily infringed by their 80 | Contribution(s) alone or by combination of their Contribution(s) 81 | with the Work to which such Contribution(s) was submitted. If You 82 | institute patent litigation against any entity (including a 83 | cross-claim or counterclaim in a lawsuit) alleging that the Work 84 | or a Contribution incorporated within the Work constitutes direct 85 | or contributory patent infringement, then any patent licenses 86 | granted to You under this License for that Work shall terminate 87 | as of the date such litigation is filed. 88 | 89 | 4. Redistribution. You may reproduce and distribute copies of the 90 | Work or Derivative Works thereof in any medium, with or without 91 | modifications, and in Source or Object form, provided that You 92 | meet the following conditions: 93 | 94 | (a) You must give any other recipients of the Work or 95 | Derivative Works a copy of this License; and 96 | 97 | (b) You must cause any modified files to carry prominent notices 98 | stating that You changed the files; and 99 | 100 | (c) You must retain, in the Source form of any Derivative Works 101 | that You distribute, all copyright, patent, trademark, and 102 | attribution notices from the Source form of the Work, 103 | excluding those notices that do not pertain to any part of 104 | the Derivative Works; and 105 | 106 | (d) If the Work includes a "NOTICE" text file as part of its 107 | distribution, then any Derivative Works that You distribute must 108 | include a readable copy of the attribution notices contained 109 | within such NOTICE file, excluding those notices that do not 110 | pertain to any part of the Derivative Works, in at least one 111 | of the following places: within a NOTICE text file distributed 112 | as part of the Derivative Works; within the Source form or 113 | documentation, if provided along with the Derivative Works; or, 114 | within a display generated by the Derivative Works, if and 115 | wherever such third-party notices normally appear. The contents 116 | of the NOTICE file are for informational purposes only and 117 | do not modify the License. You may add Your own attribution 118 | notices within Derivative Works that You distribute, alongside 119 | or as an addendum to the NOTICE text from the Work, provided 120 | that such additional attribution notices cannot be construed 121 | as modifying the License. 122 | 123 | You may add Your own copyright statement to Your modifications and 124 | may provide additional or different license terms and conditions 125 | for use, reproduction, or distribution of Your modifications, or 126 | for any such Derivative Works as a whole, provided Your use, 127 | reproduction, and distribution of the Work otherwise complies with 128 | the conditions stated in this License. 129 | 130 | 5. Submission of Contributions. Unless You explicitly state otherwise, 131 | any Contribution intentionally submitted for inclusion in the Work 132 | by You to the Licensor shall be under the terms and conditions of 133 | this License, without any additional terms or conditions. 134 | Notwithstanding the above, nothing herein shall supersede or modify 135 | the terms of any separate license agreement you may have executed 136 | with Licensor regarding such Contributions. 137 | 138 | 6. Trademarks. This License does not grant permission to use the trade 139 | names, trademarks, service marks, or product names of the Licensor, 140 | except as required for reasonable and customary use in describing the 141 | origin of the Work and reproducing the content of the NOTICE file. 142 | 143 | 7. Disclaimer of Warranty. Unless required by applicable law or 144 | agreed to in writing, Licensor provides the Work (and each 145 | Contributor provides its Contributions) on an "AS IS" BASIS, 146 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or 147 | implied, including, without limitation, any warranties or conditions 148 | of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A 149 | PARTICULAR PURPOSE. You are solely responsible for determining the 150 | appropriateness of using or redistributing the Work and assume any 151 | risks associated with Your exercise of permissions under this License. 152 | 153 | 8. Limitation of Liability. In no event and under no legal theory, 154 | whether in tort (including negligence), contract, or otherwise, 155 | unless required by applicable law (such as deliberate and grossly 156 | negligent acts) or agreed to in writing, shall any Contributor be 157 | liable to You for damages, including any direct, indirect, special, 158 | incidental, or consequential damages of any character arising as a 159 | result of this License or out of the use or inability to use the 160 | Work (including but not limited to damages for loss of goodwill, 161 | work stoppage, computer failure or malfunction, or any and all 162 | other commercial damages or losses), even if such Contributor 163 | has been advised of the possibility of such damages. 164 | 165 | 9. Accepting Warranty or Additional Liability. While redistributing 166 | the Work or Derivative Works thereof, You may choose to offer, 167 | and charge a fee for, acceptance of support, warranty, indemnity, 168 | or other liability obligations and/or rights consistent with this 169 | License. However, in accepting such obligations, You may act only 170 | on Your own behalf and on Your sole responsibility, not on behalf 171 | of any other Contributor, and only if You agree to indemnify, 172 | defend, and hold each Contributor harmless for any liability 173 | incurred by, or claims asserted against, such Contributor by reason 174 | of your accepting any such warranty or additional liability. 175 | 176 | END OF TERMS AND CONDITIONS 177 | 178 | APPENDIX: How to apply the Apache License to your work. 179 | 180 | To apply the Apache License to your work, attach the following 181 | boilerplate notice, with the fields enclosed by brackets "{}" 182 | replaced with your own identifying information. (Don't include 183 | the brackets!) The text should be enclosed in the appropriate 184 | comment syntax for the file format. We also recommend that a 185 | file or class name and description of purpose be included on the 186 | same "printed page" as the copyright notice for easier 187 | identification within third-party archives. 188 | 189 | Copyright {yyyy} {name of copyright owner} 190 | 191 | Licensed under the Apache License, Version 2.0 (the "License"); 192 | you may not use this file except in compliance with the License. 193 | You may obtain a copy of the License at 194 | 195 | http://www.apache.org/licenses/LICENSE-2.0 196 | 197 | Unless required by applicable law or agreed to in writing, software 198 | distributed under the License is distributed on an "AS IS" BASIS, 199 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 200 | See the License for the specific language governing permissions and 201 | limitations under the License. 202 | 203 | -------------------------------------------------------------------------------- /Cargo.lock: -------------------------------------------------------------------------------- 1 | # This file is automatically @generated by Cargo. 2 | # It is not intended for manual editing. 3 | version = 3 4 | 5 | [[package]] 6 | name = "anstream" 7 | version = "0.6.20" 8 | source = "registry+https://github.com/rust-lang/crates.io-index" 9 | checksum = "3ae563653d1938f79b1ab1b5e668c87c76a9930414574a6583a7b7e11a8e6192" 10 | dependencies = [ 11 | "anstyle", 12 | "anstyle-parse", 13 | "anstyle-query", 14 | "anstyle-wincon", 15 | "colorchoice", 16 | "is_terminal_polyfill", 17 | "utf8parse", 18 | ] 19 | 20 | [[package]] 21 | name = "anstyle" 22 | version = "1.0.13" 23 | source = "registry+https://github.com/rust-lang/crates.io-index" 24 | checksum = "5192cca8006f1fd4f7237516f40fa183bb07f8fbdfedaa0036de5ea9b0b45e78" 25 | 26 | [[package]] 27 | name = "anstyle-parse" 28 | version = "0.2.7" 29 | source = "registry+https://github.com/rust-lang/crates.io-index" 30 | checksum = "4e7644824f0aa2c7b9384579234ef10eb7efb6a0deb83f9630a49594dd9c15c2" 31 | dependencies = [ 32 | "utf8parse", 33 | ] 34 | 35 | [[package]] 36 | name = "anstyle-query" 37 | version = "1.1.4" 38 | source = "registry+https://github.com/rust-lang/crates.io-index" 39 | checksum = "9e231f6134f61b71076a3eab506c379d4f36122f2af15a9ff04415ea4c3339e2" 40 | dependencies = [ 41 | "windows-sys", 42 | ] 43 | 44 | [[package]] 45 | name = "anstyle-wincon" 46 | version = "3.0.10" 47 | source = "registry+https://github.com/rust-lang/crates.io-index" 48 | checksum = "3e0633414522a32ffaac8ac6cc8f748e090c5717661fddeea04219e2344f5f2a" 49 | dependencies = [ 50 | "anstyle", 51 | "once_cell_polyfill", 52 | "windows-sys", 53 | ] 54 | 55 | [[package]] 56 | name = "automod" 57 | version = "1.0.15" 58 | source = "registry+https://github.com/rust-lang/crates.io-index" 59 | checksum = "ebb4bd301db2e2ca1f5be131c24eb8ebf2d9559bc3744419e93baf8ddea7e670" 60 | dependencies = [ 61 | "proc-macro2", 62 | "quote", 63 | "syn", 64 | ] 65 | 66 | [[package]] 67 | name = "clap" 68 | version = "4.5.48" 69 | source = "registry+https://github.com/rust-lang/crates.io-index" 70 | checksum = "e2134bb3ea021b78629caa971416385309e0131b351b25e01dc16fb54e1b5fae" 71 | dependencies = [ 72 | "clap_builder", 73 | "clap_derive", 74 | ] 75 | 76 | [[package]] 77 | name = "clap_builder" 78 | version = "4.5.48" 79 | source = "registry+https://github.com/rust-lang/crates.io-index" 80 | checksum = "c2ba64afa3c0a6df7fa517765e31314e983f51dda798ffba27b988194fb65dc9" 81 | dependencies = [ 82 | "anstream", 83 | "anstyle", 84 | "clap_lex", 85 | "strsim", 86 | ] 87 | 88 | [[package]] 89 | name = "clap_derive" 90 | version = "4.5.47" 91 | source = "registry+https://github.com/rust-lang/crates.io-index" 92 | checksum = "bbfd7eae0b0f1a6e63d4b13c9c478de77c2eb546fba158ad50b4203dc24b9f9c" 93 | dependencies = [ 94 | "heck", 95 | "proc-macro2", 96 | "quote", 97 | "syn", 98 | ] 99 | 100 | [[package]] 101 | name = "clap_lex" 102 | version = "0.7.5" 103 | source = "registry+https://github.com/rust-lang/crates.io-index" 104 | checksum = "b94f61472cee1439c0b966b47e3aca9ae07e45d070759512cd390ea2bebc6675" 105 | 106 | [[package]] 107 | name = "codegenrs" 108 | version = "3.0.2" 109 | source = "registry+https://github.com/rust-lang/crates.io-index" 110 | checksum = "11a564a9c6e001f881ff5074dc1fb10aae609c82c92b7ddb47e40987be820771" 111 | dependencies = [ 112 | "clap", 113 | "difference", 114 | "normalize-line-endings", 115 | ] 116 | 117 | [[package]] 118 | name = "colorchoice" 119 | version = "1.0.4" 120 | source = "registry+https://github.com/rust-lang/crates.io-index" 121 | checksum = "b05b61dc5112cbb17e4b6cd61790d9845d13888356391624cbe7e41efeac1e75" 122 | 123 | [[package]] 124 | name = "difference" 125 | version = "2.0.0" 126 | source = "registry+https://github.com/rust-lang/crates.io-index" 127 | checksum = "524cbf6897b527295dff137cec09ecf3a05f4fddffd7dfcd1585403449e74198" 128 | 129 | [[package]] 130 | name = "fastrand" 131 | version = "2.3.0" 132 | source = "registry+https://github.com/rust-lang/crates.io-index" 133 | checksum = "37909eebbb50d72f9059c3b6d82c0463f2ff062c9e95845c43a6c9c0355411be" 134 | 135 | [[package]] 136 | name = "heck" 137 | version = "0.5.0" 138 | source = "registry+https://github.com/rust-lang/crates.io-index" 139 | checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea" 140 | 141 | [[package]] 142 | name = "imperative" 143 | version = "1.0.6" 144 | dependencies = [ 145 | "automod", 146 | "codegenrs", 147 | "multimap", 148 | "phf", 149 | "phf_codegen", 150 | "rust-stemmers", 151 | "snapbox", 152 | ] 153 | 154 | [[package]] 155 | name = "is_terminal_polyfill" 156 | version = "1.70.1" 157 | source = "registry+https://github.com/rust-lang/crates.io-index" 158 | checksum = "7943c866cc5cd64cbc25b2e01621d07fa8eb2a1a23160ee81ce38704e97b8ecf" 159 | 160 | [[package]] 161 | name = "multimap" 162 | version = "0.10.1" 163 | source = "registry+https://github.com/rust-lang/crates.io-index" 164 | checksum = "1d87ecb2933e8aeadb3e3a02b828fed80a7528047e68b4f424523a0981a3a084" 165 | dependencies = [ 166 | "serde", 167 | ] 168 | 169 | [[package]] 170 | name = "normalize-line-endings" 171 | version = "0.3.0" 172 | source = "registry+https://github.com/rust-lang/crates.io-index" 173 | checksum = "61807f77802ff30975e01f4f071c8ba10c022052f98b3294119f3e615d13e5be" 174 | 175 | [[package]] 176 | name = "once_cell_polyfill" 177 | version = "1.70.1" 178 | source = "registry+https://github.com/rust-lang/crates.io-index" 179 | checksum = "a4895175b425cb1f87721b59f0f286c2092bd4af812243672510e1ac53e2e0ad" 180 | 181 | [[package]] 182 | name = "phf" 183 | version = "0.13.1" 184 | source = "registry+https://github.com/rust-lang/crates.io-index" 185 | checksum = "c1562dc717473dbaa4c1f85a36410e03c047b2e7df7f45ee938fbef64ae7fadf" 186 | dependencies = [ 187 | "phf_shared", 188 | "serde", 189 | ] 190 | 191 | [[package]] 192 | name = "phf_codegen" 193 | version = "0.13.1" 194 | source = "registry+https://github.com/rust-lang/crates.io-index" 195 | checksum = "49aa7f9d80421bca176ca8dbfebe668cc7a2684708594ec9f3c0db0805d5d6e1" 196 | dependencies = [ 197 | "phf_generator", 198 | "phf_shared", 199 | ] 200 | 201 | [[package]] 202 | name = "phf_generator" 203 | version = "0.13.1" 204 | source = "registry+https://github.com/rust-lang/crates.io-index" 205 | checksum = "135ace3a761e564ec88c03a77317a7c6b80bb7f7135ef2544dbe054243b89737" 206 | dependencies = [ 207 | "fastrand", 208 | "phf_shared", 209 | ] 210 | 211 | [[package]] 212 | name = "phf_shared" 213 | version = "0.13.1" 214 | source = "registry+https://github.com/rust-lang/crates.io-index" 215 | checksum = "e57fef6bc5981e38c2ce2d63bfa546861309f875b8a75f092d1d54ae2d64f266" 216 | dependencies = [ 217 | "siphasher", 218 | ] 219 | 220 | [[package]] 221 | name = "proc-macro2" 222 | version = "1.0.101" 223 | source = "registry+https://github.com/rust-lang/crates.io-index" 224 | checksum = "89ae43fd86e4158d6db51ad8e2b80f313af9cc74f5c0e03ccb87de09998732de" 225 | dependencies = [ 226 | "unicode-ident", 227 | ] 228 | 229 | [[package]] 230 | name = "quote" 231 | version = "1.0.41" 232 | source = "registry+https://github.com/rust-lang/crates.io-index" 233 | checksum = "ce25767e7b499d1b604768e7cde645d14cc8584231ea6b295e9c9eb22c02e1d1" 234 | dependencies = [ 235 | "proc-macro2", 236 | ] 237 | 238 | [[package]] 239 | name = "rust-stemmers" 240 | version = "1.2.0" 241 | source = "registry+https://github.com/rust-lang/crates.io-index" 242 | checksum = "e46a2036019fdb888131db7a4c847a1063a7493f971ed94ea82c67eada63ca54" 243 | dependencies = [ 244 | "serde", 245 | "serde_derive", 246 | ] 247 | 248 | [[package]] 249 | name = "serde" 250 | version = "1.0.228" 251 | source = "registry+https://github.com/rust-lang/crates.io-index" 252 | checksum = "9a8e94ea7f378bd32cbbd37198a4a91436180c5bb472411e48b5ec2e2124ae9e" 253 | dependencies = [ 254 | "serde_core", 255 | ] 256 | 257 | [[package]] 258 | name = "serde_core" 259 | version = "1.0.228" 260 | source = "registry+https://github.com/rust-lang/crates.io-index" 261 | checksum = "41d385c7d4ca58e59fc732af25c3983b67ac852c1a25000afe1175de458b67ad" 262 | dependencies = [ 263 | "serde_derive", 264 | ] 265 | 266 | [[package]] 267 | name = "serde_derive" 268 | version = "1.0.228" 269 | source = "registry+https://github.com/rust-lang/crates.io-index" 270 | checksum = "d540f220d3187173da220f885ab66608367b6574e925011a9353e4badda91d79" 271 | dependencies = [ 272 | "proc-macro2", 273 | "quote", 274 | "syn", 275 | ] 276 | 277 | [[package]] 278 | name = "similar" 279 | version = "2.7.0" 280 | source = "registry+https://github.com/rust-lang/crates.io-index" 281 | checksum = "bbbb5d9659141646ae647b42fe094daf6c6192d1620870b449d9557f748b2daa" 282 | 283 | [[package]] 284 | name = "siphasher" 285 | version = "1.0.1" 286 | source = "registry+https://github.com/rust-lang/crates.io-index" 287 | checksum = "56199f7ddabf13fe5074ce809e7d3f42b42ae711800501b5b16ea82ad029c39d" 288 | 289 | [[package]] 290 | name = "snapbox" 291 | version = "0.6.23" 292 | source = "registry+https://github.com/rust-lang/crates.io-index" 293 | checksum = "96fa1ce81be900d083b30ec2d481e6658c2acfaa2cfc7be45ccc2cc1b820edb3" 294 | dependencies = [ 295 | "anstream", 296 | "anstyle", 297 | "normalize-line-endings", 298 | "similar", 299 | "snapbox-macros", 300 | ] 301 | 302 | [[package]] 303 | name = "snapbox-macros" 304 | version = "0.4.0" 305 | source = "registry+https://github.com/rust-lang/crates.io-index" 306 | checksum = "3b750c344002d7cc69afb9da00ebd9b5c0f8ac2eb7d115d9d45d5b5f47718d74" 307 | dependencies = [ 308 | "anstream", 309 | ] 310 | 311 | [[package]] 312 | name = "strsim" 313 | version = "0.11.1" 314 | source = "registry+https://github.com/rust-lang/crates.io-index" 315 | checksum = "7da8b5736845d9f2fcb837ea5d9e2628564b3b043a70948a3f0b778838c5fb4f" 316 | 317 | [[package]] 318 | name = "syn" 319 | version = "2.0.106" 320 | source = "registry+https://github.com/rust-lang/crates.io-index" 321 | checksum = "ede7c438028d4436d71104916910f5bb611972c5cfd7f89b8300a8186e6fada6" 322 | dependencies = [ 323 | "proc-macro2", 324 | "quote", 325 | "unicode-ident", 326 | ] 327 | 328 | [[package]] 329 | name = "unicode-ident" 330 | version = "1.0.19" 331 | source = "registry+https://github.com/rust-lang/crates.io-index" 332 | checksum = "f63a545481291138910575129486daeaf8ac54aee4387fe7906919f7830c7d9d" 333 | 334 | [[package]] 335 | name = "utf8parse" 336 | version = "0.2.2" 337 | source = "registry+https://github.com/rust-lang/crates.io-index" 338 | checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821" 339 | 340 | [[package]] 341 | name = "windows-link" 342 | version = "0.2.0" 343 | source = "registry+https://github.com/rust-lang/crates.io-index" 344 | checksum = "45e46c0661abb7180e7b9c281db115305d49ca1709ab8242adf09666d2173c65" 345 | 346 | [[package]] 347 | name = "windows-sys" 348 | version = "0.60.2" 349 | source = "registry+https://github.com/rust-lang/crates.io-index" 350 | checksum = "f2f500e4d28234f72040990ec9d39e3a6b950f9f22d3dba18416c35882612bcb" 351 | dependencies = [ 352 | "windows-targets", 353 | ] 354 | 355 | [[package]] 356 | name = "windows-targets" 357 | version = "0.53.4" 358 | source = "registry+https://github.com/rust-lang/crates.io-index" 359 | checksum = "2d42b7b7f66d2a06854650af09cfdf8713e427a439c97ad65a6375318033ac4b" 360 | dependencies = [ 361 | "windows-link", 362 | "windows_aarch64_gnullvm", 363 | "windows_aarch64_msvc", 364 | "windows_i686_gnu", 365 | "windows_i686_gnullvm", 366 | "windows_i686_msvc", 367 | "windows_x86_64_gnu", 368 | "windows_x86_64_gnullvm", 369 | "windows_x86_64_msvc", 370 | ] 371 | 372 | [[package]] 373 | name = "windows_aarch64_gnullvm" 374 | version = "0.53.0" 375 | source = "registry+https://github.com/rust-lang/crates.io-index" 376 | checksum = "86b8d5f90ddd19cb4a147a5fa63ca848db3df085e25fee3cc10b39b6eebae764" 377 | 378 | [[package]] 379 | name = "windows_aarch64_msvc" 380 | version = "0.53.0" 381 | source = "registry+https://github.com/rust-lang/crates.io-index" 382 | checksum = "c7651a1f62a11b8cbd5e0d42526e55f2c99886c77e007179efff86c2b137e66c" 383 | 384 | [[package]] 385 | name = "windows_i686_gnu" 386 | version = "0.53.0" 387 | source = "registry+https://github.com/rust-lang/crates.io-index" 388 | checksum = "c1dc67659d35f387f5f6c479dc4e28f1d4bb90ddd1a5d3da2e5d97b42d6272c3" 389 | 390 | [[package]] 391 | name = "windows_i686_gnullvm" 392 | version = "0.53.0" 393 | source = "registry+https://github.com/rust-lang/crates.io-index" 394 | checksum = "9ce6ccbdedbf6d6354471319e781c0dfef054c81fbc7cf83f338a4296c0cae11" 395 | 396 | [[package]] 397 | name = "windows_i686_msvc" 398 | version = "0.53.0" 399 | source = "registry+https://github.com/rust-lang/crates.io-index" 400 | checksum = "581fee95406bb13382d2f65cd4a908ca7b1e4c2f1917f143ba16efe98a589b5d" 401 | 402 | [[package]] 403 | name = "windows_x86_64_gnu" 404 | version = "0.53.0" 405 | source = "registry+https://github.com/rust-lang/crates.io-index" 406 | checksum = "2e55b5ac9ea33f2fc1716d1742db15574fd6fc8dadc51caab1c16a3d3b4190ba" 407 | 408 | [[package]] 409 | name = "windows_x86_64_gnullvm" 410 | version = "0.53.0" 411 | source = "registry+https://github.com/rust-lang/crates.io-index" 412 | checksum = "0a6e035dd0599267ce1ee132e51c27dd29437f63325753051e71dd9e42406c57" 413 | 414 | [[package]] 415 | name = "windows_x86_64_msvc" 416 | version = "0.53.0" 417 | source = "registry+https://github.com/rust-lang/crates.io-index" 418 | checksum = "271414315aff87387382ec3d271b52d7ae78726f5d44ac98b4f4030c91880486" 419 | -------------------------------------------------------------------------------- /src/wordlist_codegen.rs: -------------------------------------------------------------------------------- 1 | // This file is @generated by tests/testsuite/codegen.rs 2 | 3 | pub(crate) static ACCEPT_STEM: phf::Set<&'static str> = ::phf::Set { 4 | map: ::phf::Map { 5 | key: 16287231350648472473, 6 | disps: &[(0, 0)], 7 | entries: &[("accept", ())], 8 | }, 9 | }; 10 | 11 | pub(crate) static ACCESS_STEM: phf::Set<&'static str> = ::phf::Set { 12 | map: ::phf::Map { 13 | key: 16287231350648472473, 14 | disps: &[(0, 0)], 15 | entries: &[("access", ())], 16 | }, 17 | }; 18 | 19 | pub(crate) static ADD_STEM: phf::Set<&'static str> = ::phf::Set { 20 | map: ::phf::Map { 21 | key: 16287231350648472473, 22 | disps: &[(0, 0)], 23 | entries: &[("add", ())], 24 | }, 25 | }; 26 | 27 | pub(crate) static ADJUST_STEM: phf::Set<&'static str> = ::phf::Set { 28 | map: ::phf::Map { 29 | key: 16287231350648472473, 30 | disps: &[(0, 0)], 31 | entries: &[("adjust", ())], 32 | }, 33 | }; 34 | 35 | pub(crate) static AGGREG_STEM: phf::Set<&'static str> = ::phf::Set { 36 | map: ::phf::Map { 37 | key: 16287231350648472473, 38 | disps: &[(0, 0)], 39 | entries: &[("aggregate", ())], 40 | }, 41 | }; 42 | 43 | pub(crate) static ALLOW_STEM: phf::Set<&'static str> = ::phf::Set { 44 | map: ::phf::Map { 45 | key: 16287231350648472473, 46 | disps: &[(0, 0)], 47 | entries: &[("allow", ())], 48 | }, 49 | }; 50 | 51 | pub(crate) static APPEND_STEM: phf::Set<&'static str> = ::phf::Set { 52 | map: ::phf::Map { 53 | key: 16287231350648472473, 54 | disps: &[(0, 0)], 55 | entries: &[("append", ())], 56 | }, 57 | }; 58 | 59 | pub(crate) static APPLI_STEM: phf::Set<&'static str> = ::phf::Set { 60 | map: ::phf::Map { 61 | key: 16287231350648472473, 62 | disps: &[(0, 0)], 63 | entries: &[("apply", ())], 64 | }, 65 | }; 66 | 67 | pub(crate) static ARCHIV_STEM: phf::Set<&'static str> = ::phf::Set { 68 | map: ::phf::Map { 69 | key: 16287231350648472473, 70 | disps: &[(0, 0)], 71 | entries: &[("archive", ())], 72 | }, 73 | }; 74 | 75 | pub(crate) static ASSERT_STEM: phf::Set<&'static str> = ::phf::Set { 76 | map: ::phf::Map { 77 | key: 16287231350648472473, 78 | disps: &[(0, 0)], 79 | entries: &[("assert", ())], 80 | }, 81 | }; 82 | 83 | pub(crate) static ASSIGN_STEM: phf::Set<&'static str> = ::phf::Set { 84 | map: ::phf::Map { 85 | key: 16287231350648472473, 86 | disps: &[(0, 0)], 87 | entries: &[("assign", ())], 88 | }, 89 | }; 90 | 91 | pub(crate) static ATTEMPT_STEM: phf::Set<&'static str> = ::phf::Set { 92 | map: ::phf::Map { 93 | key: 16287231350648472473, 94 | disps: &[(0, 0)], 95 | entries: &[("attempt", ())], 96 | }, 97 | }; 98 | 99 | pub(crate) static AUTHENT_STEM: phf::Set<&'static str> = ::phf::Set { 100 | map: ::phf::Map { 101 | key: 16287231350648472473, 102 | disps: &[(0, 0)], 103 | entries: &[("authenticate", ())], 104 | }, 105 | }; 106 | 107 | pub(crate) static AUTHOR_STEM: phf::Set<&'static str> = ::phf::Set { 108 | map: ::phf::Map { 109 | key: 16287231350648472473, 110 | disps: &[(0, 0)], 111 | entries: &[("authorize", ())], 112 | }, 113 | }; 114 | 115 | pub(crate) static BREAK_STEM: phf::Set<&'static str> = ::phf::Set { 116 | map: ::phf::Map { 117 | key: 16287231350648472473, 118 | disps: &[(0, 0)], 119 | entries: &[("break", ())], 120 | }, 121 | }; 122 | 123 | pub(crate) static BUILD_STEM: phf::Set<&'static str> = ::phf::Set { 124 | map: ::phf::Map { 125 | key: 16287231350648472473, 126 | disps: &[(0, 0)], 127 | entries: &[("build", ())], 128 | }, 129 | }; 130 | 131 | pub(crate) static CACH_STEM: phf::Set<&'static str> = ::phf::Set { 132 | map: ::phf::Map { 133 | key: 16287231350648472473, 134 | disps: &[(0, 0)], 135 | entries: &[("cache", ())], 136 | }, 137 | }; 138 | 139 | pub(crate) static CALCUL_STEM: phf::Set<&'static str> = ::phf::Set { 140 | map: ::phf::Map { 141 | key: 16287231350648472473, 142 | disps: &[(0, 0)], 143 | entries: &[("calculate", ())], 144 | }, 145 | }; 146 | 147 | pub(crate) static CALL_STEM: phf::Set<&'static str> = ::phf::Set { 148 | map: ::phf::Map { 149 | key: 16287231350648472473, 150 | disps: &[(0, 0)], 151 | entries: &[("call", ())], 152 | }, 153 | }; 154 | 155 | pub(crate) static CANCEL_STEM: phf::Set<&'static str> = ::phf::Set { 156 | map: ::phf::Map { 157 | key: 16287231350648472473, 158 | disps: &[(0, 0)], 159 | entries: &[("cancel", ())], 160 | }, 161 | }; 162 | 163 | pub(crate) static CAPTUR_STEM: phf::Set<&'static str> = ::phf::Set { 164 | map: ::phf::Map { 165 | key: 16287231350648472473, 166 | disps: &[(0, 0)], 167 | entries: &[("capture", ())], 168 | }, 169 | }; 170 | 171 | pub(crate) static CHANG_STEM: phf::Set<&'static str> = ::phf::Set { 172 | map: ::phf::Map { 173 | key: 16287231350648472473, 174 | disps: &[(0, 0)], 175 | entries: &[("change", ())], 176 | }, 177 | }; 178 | 179 | pub(crate) static CHECK_STEM: phf::Set<&'static str> = ::phf::Set { 180 | map: ::phf::Map { 181 | key: 16287231350648472473, 182 | disps: &[(0, 0)], 183 | entries: &[("check", ())], 184 | }, 185 | }; 186 | 187 | pub(crate) static CLEAN_STEM: phf::Set<&'static str> = ::phf::Set { 188 | map: ::phf::Map { 189 | key: 16287231350648472473, 190 | disps: &[(0, 0)], 191 | entries: &[("clean", ())], 192 | }, 193 | }; 194 | 195 | pub(crate) static CLEAR_STEM: phf::Set<&'static str> = ::phf::Set { 196 | map: ::phf::Map { 197 | key: 16287231350648472473, 198 | disps: &[(0, 0)], 199 | entries: &[("clear", ())], 200 | }, 201 | }; 202 | 203 | pub(crate) static CLOSE_STEM: phf::Set<&'static str> = ::phf::Set { 204 | map: ::phf::Map { 205 | key: 16287231350648472473, 206 | disps: &[(0, 0)], 207 | entries: &[("close", ())], 208 | }, 209 | }; 210 | 211 | pub(crate) static COLLECT_STEM: phf::Set<&'static str> = ::phf::Set { 212 | map: ::phf::Map { 213 | key: 16287231350648472473, 214 | disps: &[(0, 0)], 215 | entries: &[("collect", ())], 216 | }, 217 | }; 218 | 219 | pub(crate) static COMBIN_STEM: phf::Set<&'static str> = ::phf::Set { 220 | map: ::phf::Map { 221 | key: 16287231350648472473, 222 | disps: &[(0, 0)], 223 | entries: &[("combine", ())], 224 | }, 225 | }; 226 | 227 | pub(crate) static COMMIT_STEM: phf::Set<&'static str> = ::phf::Set { 228 | map: ::phf::Map { 229 | key: 16287231350648472473, 230 | disps: &[(0, 0)], 231 | entries: &[("commit", ())], 232 | }, 233 | }; 234 | 235 | pub(crate) static COMPAR_STEM: phf::Set<&'static str> = ::phf::Set { 236 | map: ::phf::Map { 237 | key: 16287231350648472473, 238 | disps: &[(0, 0)], 239 | entries: &[("compare", ())], 240 | }, 241 | }; 242 | 243 | pub(crate) static COMPUT_STEM: phf::Set<&'static str> = ::phf::Set { 244 | map: ::phf::Map { 245 | key: 16287231350648472473, 246 | disps: &[(0, 0)], 247 | entries: &[("compute", ())], 248 | }, 249 | }; 250 | 251 | pub(crate) static CONFIGUR_STEM: phf::Set<&'static str> = ::phf::Set { 252 | map: ::phf::Map { 253 | key: 16287231350648472473, 254 | disps: &[(0, 0)], 255 | entries: &[("configure", ())], 256 | }, 257 | }; 258 | 259 | pub(crate) static CONFIRM_STEM: phf::Set<&'static str> = ::phf::Set { 260 | map: ::phf::Map { 261 | key: 16287231350648472473, 262 | disps: &[(0, 0)], 263 | entries: &[("confirm", ())], 264 | }, 265 | }; 266 | 267 | pub(crate) static CONNECT_STEM: phf::Set<&'static str> = ::phf::Set { 268 | map: ::phf::Map { 269 | key: 16287231350648472473, 270 | disps: &[(0, 0)], 271 | entries: &[("connect", ())], 272 | }, 273 | }; 274 | 275 | pub(crate) static CONSTRUCT_STEM: phf::Set<&'static str> = ::phf::Set { 276 | map: ::phf::Map { 277 | key: 16287231350648472473, 278 | disps: &[(0, 0)], 279 | entries: &[("construct", ())], 280 | }, 281 | }; 282 | 283 | pub(crate) static CONTROL_STEM: phf::Set<&'static str> = ::phf::Set { 284 | map: ::phf::Map { 285 | key: 16287231350648472473, 286 | disps: &[(0, 0)], 287 | entries: &[("control", ())], 288 | }, 289 | }; 290 | 291 | pub(crate) static CONVERT_STEM: phf::Set<&'static str> = ::phf::Set { 292 | map: ::phf::Map { 293 | key: 16287231350648472473, 294 | disps: &[(0, 0)], 295 | entries: &[("convert", ())], 296 | }, 297 | }; 298 | 299 | pub(crate) static COPI_STEM: phf::Set<&'static str> = ::phf::Set { 300 | map: ::phf::Map { 301 | key: 16287231350648472473, 302 | disps: &[(0, 0)], 303 | entries: &[("copy", ())], 304 | }, 305 | }; 306 | 307 | pub(crate) static COUNT_STEM: phf::Set<&'static str> = ::phf::Set { 308 | map: ::phf::Map { 309 | key: 16287231350648472473, 310 | disps: &[(0, 0)], 311 | entries: &[("count", ())], 312 | }, 313 | }; 314 | 315 | pub(crate) static CREAT_STEM: phf::Set<&'static str> = ::phf::Set { 316 | map: ::phf::Map { 317 | key: 16287231350648472473, 318 | disps: &[(0, 0)], 319 | entries: &[("create", ())], 320 | }, 321 | }; 322 | 323 | pub(crate) static CUSTOM_STEM: phf::Set<&'static str> = ::phf::Set { 324 | map: ::phf::Map { 325 | key: 16287231350648472473, 326 | disps: &[(0, 0)], 327 | entries: &[("customize", ())], 328 | }, 329 | }; 330 | 331 | pub(crate) static DECLAR_STEM: phf::Set<&'static str> = ::phf::Set { 332 | map: ::phf::Map { 333 | key: 16287231350648472473, 334 | disps: &[(0, 0)], 335 | entries: &[("declare", ())], 336 | }, 337 | }; 338 | 339 | pub(crate) static DECOD_STEM: phf::Set<&'static str> = ::phf::Set { 340 | map: ::phf::Map { 341 | key: 16287231350648472473, 342 | disps: &[(0, 0)], 343 | entries: &[("decode", ())], 344 | }, 345 | }; 346 | 347 | pub(crate) static DECOR_STEM: phf::Set<&'static str> = ::phf::Set { 348 | map: ::phf::Map { 349 | key: 16287231350648472473, 350 | disps: &[(0, 0)], 351 | entries: &[("decorate", ())], 352 | }, 353 | }; 354 | 355 | pub(crate) static DEFIN_STEM: phf::Set<&'static str> = ::phf::Set { 356 | map: ::phf::Map { 357 | key: 16287231350648472473, 358 | disps: &[(0, 0)], 359 | entries: &[("define", ())], 360 | }, 361 | }; 362 | 363 | pub(crate) static DELEG_STEM: phf::Set<&'static str> = ::phf::Set { 364 | map: ::phf::Map { 365 | key: 16287231350648472473, 366 | disps: &[(0, 0)], 367 | entries: &[("delegate", ())], 368 | }, 369 | }; 370 | 371 | pub(crate) static DELET_STEM: phf::Set<&'static str> = ::phf::Set { 372 | map: ::phf::Map { 373 | key: 16287231350648472473, 374 | disps: &[(0, 0)], 375 | entries: &[("delete", ())], 376 | }, 377 | }; 378 | 379 | pub(crate) static DEPREC_STEM: phf::Set<&'static str> = ::phf::Set { 380 | map: ::phf::Map { 381 | key: 16287231350648472473, 382 | disps: &[(0, 0)], 383 | entries: &[("deprecate", ())], 384 | }, 385 | }; 386 | 387 | pub(crate) static DERIV_STEM: phf::Set<&'static str> = ::phf::Set { 388 | map: ::phf::Map { 389 | key: 16287231350648472473, 390 | disps: &[(0, 0)], 391 | entries: &[("derive", ())], 392 | }, 393 | }; 394 | 395 | pub(crate) static DESCRIB_STEM: phf::Set<&'static str> = ::phf::Set { 396 | map: ::phf::Map { 397 | key: 16287231350648472473, 398 | disps: &[(0, 0)], 399 | entries: &[("describe", ())], 400 | }, 401 | }; 402 | 403 | pub(crate) static DETECT_STEM: phf::Set<&'static str> = ::phf::Set { 404 | map: ::phf::Map { 405 | key: 16287231350648472473, 406 | disps: &[(0, 0)], 407 | entries: &[("detect", ())], 408 | }, 409 | }; 410 | 411 | pub(crate) static DETERMIN_STEM: phf::Set<&'static str> = ::phf::Set { 412 | map: ::phf::Map { 413 | key: 16287231350648472473, 414 | disps: &[(0, 0)], 415 | entries: &[("determine", ())], 416 | }, 417 | }; 418 | 419 | pub(crate) static DISPLAY_STEM: phf::Set<&'static str> = ::phf::Set { 420 | map: ::phf::Map { 421 | key: 16287231350648472473, 422 | disps: &[(0, 0)], 423 | entries: &[("display", ())], 424 | }, 425 | }; 426 | 427 | pub(crate) static DOWNLOAD_STEM: phf::Set<&'static str> = ::phf::Set { 428 | map: ::phf::Map { 429 | key: 16287231350648472473, 430 | disps: &[(0, 0)], 431 | entries: &[("download", ())], 432 | }, 433 | }; 434 | 435 | pub(crate) static DROP_STEM: phf::Set<&'static str> = ::phf::Set { 436 | map: ::phf::Map { 437 | key: 16287231350648472473, 438 | disps: &[(0, 0)], 439 | entries: &[("drop", ())], 440 | }, 441 | }; 442 | 443 | pub(crate) static DUMP_STEM: phf::Set<&'static str> = ::phf::Set { 444 | map: ::phf::Map { 445 | key: 16287231350648472473, 446 | disps: &[(0, 0)], 447 | entries: &[("dump", ())], 448 | }, 449 | }; 450 | 451 | pub(crate) static EMIT_STEM: phf::Set<&'static str> = ::phf::Set { 452 | map: ::phf::Map { 453 | key: 16287231350648472473, 454 | disps: &[(0, 0)], 455 | entries: &[("emit", ())], 456 | }, 457 | }; 458 | 459 | pub(crate) static EMPTI_STEM: phf::Set<&'static str> = ::phf::Set { 460 | map: ::phf::Map { 461 | key: 16287231350648472473, 462 | disps: &[(0, 0)], 463 | entries: &[("empty", ())], 464 | }, 465 | }; 466 | 467 | pub(crate) static ENABL_STEM: phf::Set<&'static str> = ::phf::Set { 468 | map: ::phf::Map { 469 | key: 16287231350648472473, 470 | disps: &[(0, 0)], 471 | entries: &[("enable", ())], 472 | }, 473 | }; 474 | 475 | pub(crate) static ENCAPSUL_STEM: phf::Set<&'static str> = ::phf::Set { 476 | map: ::phf::Map { 477 | key: 16287231350648472473, 478 | disps: &[(0, 0)], 479 | entries: &[("encapsulate", ())], 480 | }, 481 | }; 482 | 483 | pub(crate) static ENCOD_STEM: phf::Set<&'static str> = ::phf::Set { 484 | map: ::phf::Map { 485 | key: 16287231350648472473, 486 | disps: &[(0, 0)], 487 | entries: &[("encode", ())], 488 | }, 489 | }; 490 | 491 | pub(crate) static END_STEM: phf::Set<&'static str> = ::phf::Set { 492 | map: ::phf::Map { 493 | key: 16287231350648472473, 494 | disps: &[(0, 0)], 495 | entries: &[("end", ())], 496 | }, 497 | }; 498 | 499 | pub(crate) static ENSUR_STEM: phf::Set<&'static str> = ::phf::Set { 500 | map: ::phf::Map { 501 | key: 16287231350648472473, 502 | disps: &[(0, 0)], 503 | entries: &[("ensure", ())], 504 | }, 505 | }; 506 | 507 | pub(crate) static ENUMER_STEM: phf::Set<&'static str> = ::phf::Set { 508 | map: ::phf::Map { 509 | key: 16287231350648472473, 510 | disps: &[(0, 0)], 511 | entries: &[("enumerate", ())], 512 | }, 513 | }; 514 | 515 | pub(crate) static ESTABLISH_STEM: phf::Set<&'static str> = ::phf::Set { 516 | map: ::phf::Map { 517 | key: 16287231350648472473, 518 | disps: &[(0, 0)], 519 | entries: &[("establish", ())], 520 | }, 521 | }; 522 | 523 | pub(crate) static EVALU_STEM: phf::Set<&'static str> = ::phf::Set { 524 | map: ::phf::Map { 525 | key: 16287231350648472473, 526 | disps: &[(0, 0)], 527 | entries: &[("evaluate", ())], 528 | }, 529 | }; 530 | 531 | pub(crate) static EXAMIN_STEM: phf::Set<&'static str> = ::phf::Set { 532 | map: ::phf::Map { 533 | key: 16287231350648472473, 534 | disps: &[(0, 0)], 535 | entries: &[("examine", ())], 536 | }, 537 | }; 538 | 539 | pub(crate) static EXECUT_STEM: phf::Set<&'static str> = ::phf::Set { 540 | map: ::phf::Map { 541 | key: 16287231350648472473, 542 | disps: &[(0, 0)], 543 | entries: &[("execute", ())], 544 | }, 545 | }; 546 | 547 | pub(crate) static EXIT_STEM: phf::Set<&'static str> = ::phf::Set { 548 | map: ::phf::Map { 549 | key: 16287231350648472473, 550 | disps: &[(0, 0)], 551 | entries: &[("exit", ())], 552 | }, 553 | }; 554 | 555 | pub(crate) static EXPAND_STEM: phf::Set<&'static str> = ::phf::Set { 556 | map: ::phf::Map { 557 | key: 16287231350648472473, 558 | disps: &[(0, 0)], 559 | entries: &[("expand", ())], 560 | }, 561 | }; 562 | 563 | pub(crate) static EXPECT_STEM: phf::Set<&'static str> = ::phf::Set { 564 | map: ::phf::Map { 565 | key: 16287231350648472473, 566 | disps: &[(0, 0)], 567 | entries: &[("expect", ())], 568 | }, 569 | }; 570 | 571 | pub(crate) static EXPORT_STEM: phf::Set<&'static str> = ::phf::Set { 572 | map: ::phf::Map { 573 | key: 16287231350648472473, 574 | disps: &[(0, 0)], 575 | entries: &[("export", ())], 576 | }, 577 | }; 578 | 579 | pub(crate) static EXTEND_STEM: phf::Set<&'static str> = ::phf::Set { 580 | map: ::phf::Map { 581 | key: 16287231350648472473, 582 | disps: &[(0, 0)], 583 | entries: &[("extend", ())], 584 | }, 585 | }; 586 | 587 | pub(crate) static EXTRACT_STEM: phf::Set<&'static str> = ::phf::Set { 588 | map: ::phf::Map { 589 | key: 16287231350648472473, 590 | disps: &[(0, 0)], 591 | entries: &[("extract", ())], 592 | }, 593 | }; 594 | 595 | pub(crate) static FEED_STEM: phf::Set<&'static str> = ::phf::Set { 596 | map: ::phf::Map { 597 | key: 16287231350648472473, 598 | disps: &[(0, 0)], 599 | entries: &[("feed", ())], 600 | }, 601 | }; 602 | 603 | pub(crate) static FETCH_STEM: phf::Set<&'static str> = ::phf::Set { 604 | map: ::phf::Map { 605 | key: 16287231350648472473, 606 | disps: &[(0, 0)], 607 | entries: &[("fetch", ())], 608 | }, 609 | }; 610 | 611 | pub(crate) static FILL_STEM: phf::Set<&'static str> = ::phf::Set { 612 | map: ::phf::Map { 613 | key: 16287231350648472473, 614 | disps: &[(0, 0)], 615 | entries: &[("fill", ())], 616 | }, 617 | }; 618 | 619 | pub(crate) static FILTER_STEM: phf::Set<&'static str> = ::phf::Set { 620 | map: ::phf::Map { 621 | key: 16287231350648472473, 622 | disps: &[(0, 0)], 623 | entries: &[("filter", ())], 624 | }, 625 | }; 626 | 627 | pub(crate) static FINAL_STEM: phf::Set<&'static str> = ::phf::Set { 628 | map: ::phf::Map { 629 | key: 16287231350648472473, 630 | disps: &[(0, 0)], 631 | entries: &[("finalize", ())], 632 | }, 633 | }; 634 | 635 | pub(crate) static FIND_STEM: phf::Set<&'static str> = ::phf::Set { 636 | map: ::phf::Map { 637 | key: 16287231350648472473, 638 | disps: &[(0, 0)], 639 | entries: &[("find", ())], 640 | }, 641 | }; 642 | 643 | pub(crate) static FIRE_STEM: phf::Set<&'static str> = ::phf::Set { 644 | map: ::phf::Map { 645 | key: 16287231350648472473, 646 | disps: &[(0, 0)], 647 | entries: &[("fire", ())], 648 | }, 649 | }; 650 | 651 | pub(crate) static FIX_STEM: phf::Set<&'static str> = ::phf::Set { 652 | map: ::phf::Map { 653 | key: 16287231350648472473, 654 | disps: &[(0, 0)], 655 | entries: &[("fix", ())], 656 | }, 657 | }; 658 | 659 | pub(crate) static FLAG_STEM: phf::Set<&'static str> = ::phf::Set { 660 | map: ::phf::Map { 661 | key: 16287231350648472473, 662 | disps: &[(0, 0)], 663 | entries: &[("flag", ())], 664 | }, 665 | }; 666 | 667 | pub(crate) static FORC_STEM: phf::Set<&'static str> = ::phf::Set { 668 | map: ::phf::Map { 669 | key: 16287231350648472473, 670 | disps: &[(0, 0)], 671 | entries: &[("force", ())], 672 | }, 673 | }; 674 | 675 | pub(crate) static FORMAT_STEM: phf::Set<&'static str> = ::phf::Set { 676 | map: ::phf::Map { 677 | key: 16287231350648472473, 678 | disps: &[(0, 0)], 679 | entries: &[("format", ())], 680 | }, 681 | }; 682 | 683 | pub(crate) static FORWARD_STEM: phf::Set<&'static str> = ::phf::Set { 684 | map: ::phf::Map { 685 | key: 16287231350648472473, 686 | disps: &[(0, 0)], 687 | entries: &[("forward", ())], 688 | }, 689 | }; 690 | 691 | pub(crate) static GENERAT_STEM: phf::Set<&'static str> = ::phf::Set { 692 | map: ::phf::Map { 693 | key: 16287231350648472473, 694 | disps: &[(0, 0)], 695 | entries: &[("generate", ())], 696 | }, 697 | }; 698 | 699 | pub(crate) static GET_STEM: phf::Set<&'static str> = ::phf::Set { 700 | map: ::phf::Map { 701 | key: 16287231350648472473, 702 | disps: &[(0, 0)], 703 | entries: &[("get", ())], 704 | }, 705 | }; 706 | 707 | pub(crate) static GIVE_STEM: phf::Set<&'static str> = ::phf::Set { 708 | map: ::phf::Map { 709 | key: 16287231350648472473, 710 | disps: &[(0, 0)], 711 | entries: &[("give", ())], 712 | }, 713 | }; 714 | 715 | pub(crate) static GO_STEM: phf::Set<&'static str> = ::phf::Set { 716 | map: ::phf::Map { 717 | key: 16287231350648472473, 718 | disps: &[(0, 0)], 719 | entries: &[("go", ())], 720 | }, 721 | }; 722 | 723 | pub(crate) static GROUP_STEM: phf::Set<&'static str> = ::phf::Set { 724 | map: ::phf::Map { 725 | key: 16287231350648472473, 726 | disps: &[(0, 0)], 727 | entries: &[("group", ())], 728 | }, 729 | }; 730 | 731 | pub(crate) static HANDL_STEM: phf::Set<&'static str> = ::phf::Set { 732 | map: ::phf::Map { 733 | key: 16287231350648472473, 734 | disps: &[(0, 0)], 735 | entries: &[("handle", ())], 736 | }, 737 | }; 738 | 739 | pub(crate) static HELP_STEM: phf::Set<&'static str> = ::phf::Set { 740 | map: ::phf::Map { 741 | key: 16287231350648472473, 742 | disps: &[(0, 0)], 743 | entries: &[("help", ())], 744 | }, 745 | }; 746 | 747 | pub(crate) static HOLD_STEM: phf::Set<&'static str> = ::phf::Set { 748 | map: ::phf::Map { 749 | key: 16287231350648472473, 750 | disps: &[(0, 0)], 751 | entries: &[("hold", ())], 752 | }, 753 | }; 754 | 755 | pub(crate) static IDENTIFI_STEM: phf::Set<&'static str> = ::phf::Set { 756 | map: ::phf::Map { 757 | key: 16287231350648472473, 758 | disps: &[(0, 0)], 759 | entries: &[("identify", ())], 760 | }, 761 | }; 762 | 763 | pub(crate) static IMPLEMENT_STEM: phf::Set<&'static str> = ::phf::Set { 764 | map: ::phf::Map { 765 | key: 16287231350648472473, 766 | disps: &[(0, 0)], 767 | entries: &[("implement", ())], 768 | }, 769 | }; 770 | 771 | pub(crate) static IMPORT_STEM: phf::Set<&'static str> = ::phf::Set { 772 | map: ::phf::Map { 773 | key: 16287231350648472473, 774 | disps: &[(0, 0)], 775 | entries: &[("import", ())], 776 | }, 777 | }; 778 | 779 | pub(crate) static INDIC_STEM: phf::Set<&'static str> = ::phf::Set { 780 | map: ::phf::Map { 781 | key: 16287231350648472473, 782 | disps: &[(0, 0)], 783 | entries: &[("indicate", ())], 784 | }, 785 | }; 786 | 787 | pub(crate) static INIT_STEM: phf::Set<&'static str> = ::phf::Set { 788 | map: ::phf::Map { 789 | key: 16287231350648472473, 790 | disps: &[(0, 0)], 791 | entries: &[("init", ())], 792 | }, 793 | }; 794 | 795 | pub(crate) static INITI_STEM: phf::Set<&'static str> = ::phf::Set { 796 | map: ::phf::Map { 797 | key: 16263683158343804936, 798 | disps: &[(1, 0)], 799 | entries: &[("initiate", ()), ("initialize", ())], 800 | }, 801 | }; 802 | 803 | pub(crate) static INITIALIS_STEM: phf::Set<&'static str> = ::phf::Set { 804 | map: ::phf::Map { 805 | key: 16287231350648472473, 806 | disps: &[(0, 0)], 807 | entries: &[("initialise", ())], 808 | }, 809 | }; 810 | 811 | pub(crate) static INPUT_STEM: phf::Set<&'static str> = ::phf::Set { 812 | map: ::phf::Map { 813 | key: 16287231350648472473, 814 | disps: &[(0, 0)], 815 | entries: &[("input", ())], 816 | }, 817 | }; 818 | 819 | pub(crate) static INSERT_STEM: phf::Set<&'static str> = ::phf::Set { 820 | map: ::phf::Map { 821 | key: 16287231350648472473, 822 | disps: &[(0, 0)], 823 | entries: &[("insert", ())], 824 | }, 825 | }; 826 | 827 | pub(crate) static INSTANTI_STEM: phf::Set<&'static str> = ::phf::Set { 828 | map: ::phf::Map { 829 | key: 16287231350648472473, 830 | disps: &[(0, 0)], 831 | entries: &[("instantiate", ())], 832 | }, 833 | }; 834 | 835 | pub(crate) static INTERCEPT_STEM: phf::Set<&'static str> = ::phf::Set { 836 | map: ::phf::Map { 837 | key: 16287231350648472473, 838 | disps: &[(0, 0)], 839 | entries: &[("intercept", ())], 840 | }, 841 | }; 842 | 843 | pub(crate) static INVOK_STEM: phf::Set<&'static str> = ::phf::Set { 844 | map: ::phf::Map { 845 | key: 16287231350648472473, 846 | disps: &[(0, 0)], 847 | entries: &[("invoke", ())], 848 | }, 849 | }; 850 | 851 | pub(crate) static ITER_STEM: phf::Set<&'static str> = ::phf::Set { 852 | map: ::phf::Map { 853 | key: 16287231350648472473, 854 | disps: &[(0, 0)], 855 | entries: &[("iterate", ())], 856 | }, 857 | }; 858 | 859 | pub(crate) static JOIN_STEM: phf::Set<&'static str> = ::phf::Set { 860 | map: ::phf::Map { 861 | key: 16287231350648472473, 862 | disps: &[(0, 0)], 863 | entries: &[("join", ())], 864 | }, 865 | }; 866 | 867 | pub(crate) static KEEP_STEM: phf::Set<&'static str> = ::phf::Set { 868 | map: ::phf::Map { 869 | key: 16287231350648472473, 870 | disps: &[(0, 0)], 871 | entries: &[("keep", ())], 872 | }, 873 | }; 874 | 875 | pub(crate) static LAUNCH_STEM: phf::Set<&'static str> = ::phf::Set { 876 | map: ::phf::Map { 877 | key: 16287231350648472473, 878 | disps: &[(0, 0)], 879 | entries: &[("launch", ())], 880 | }, 881 | }; 882 | 883 | pub(crate) static LIST_STEM: phf::Set<&'static str> = ::phf::Set { 884 | map: ::phf::Map { 885 | key: 16287231350648472473, 886 | disps: &[(0, 0)], 887 | entries: &[("list", ())], 888 | }, 889 | }; 890 | 891 | pub(crate) static LISTEN_STEM: phf::Set<&'static str> = ::phf::Set { 892 | map: ::phf::Map { 893 | key: 16287231350648472473, 894 | disps: &[(0, 0)], 895 | entries: &[("listen", ())], 896 | }, 897 | }; 898 | 899 | pub(crate) static LOAD_STEM: phf::Set<&'static str> = ::phf::Set { 900 | map: ::phf::Map { 901 | key: 16287231350648472473, 902 | disps: &[(0, 0)], 903 | entries: &[("load", ())], 904 | }, 905 | }; 906 | 907 | pub(crate) static LOG_STEM: phf::Set<&'static str> = ::phf::Set { 908 | map: ::phf::Map { 909 | key: 16287231350648472473, 910 | disps: &[(0, 0)], 911 | entries: &[("log", ())], 912 | }, 913 | }; 914 | 915 | pub(crate) static LOOK_STEM: phf::Set<&'static str> = ::phf::Set { 916 | map: ::phf::Map { 917 | key: 16287231350648472473, 918 | disps: &[(0, 0)], 919 | entries: &[("look", ())], 920 | }, 921 | }; 922 | 923 | pub(crate) static MAKE_STEM: phf::Set<&'static str> = ::phf::Set { 924 | map: ::phf::Map { 925 | key: 16287231350648472473, 926 | disps: &[(0, 0)], 927 | entries: &[("make", ())], 928 | }, 929 | }; 930 | 931 | pub(crate) static MANAG_STEM: phf::Set<&'static str> = ::phf::Set { 932 | map: ::phf::Map { 933 | key: 16287231350648472473, 934 | disps: &[(0, 0)], 935 | entries: &[("manage", ())], 936 | }, 937 | }; 938 | 939 | pub(crate) static MANIPUL_STEM: phf::Set<&'static str> = ::phf::Set { 940 | map: ::phf::Map { 941 | key: 16287231350648472473, 942 | disps: &[(0, 0)], 943 | entries: &[("manipulate", ())], 944 | }, 945 | }; 946 | 947 | pub(crate) static MAP_STEM: phf::Set<&'static str> = ::phf::Set { 948 | map: ::phf::Map { 949 | key: 16287231350648472473, 950 | disps: &[(0, 0)], 951 | entries: &[("map", ())], 952 | }, 953 | }; 954 | 955 | pub(crate) static MARK_STEM: phf::Set<&'static str> = ::phf::Set { 956 | map: ::phf::Map { 957 | key: 16287231350648472473, 958 | disps: &[(0, 0)], 959 | entries: &[("mark", ())], 960 | }, 961 | }; 962 | 963 | pub(crate) static MATCH_STEM: phf::Set<&'static str> = ::phf::Set { 964 | map: ::phf::Map { 965 | key: 16287231350648472473, 966 | disps: &[(0, 0)], 967 | entries: &[("match", ())], 968 | }, 969 | }; 970 | 971 | pub(crate) static MERG_STEM: phf::Set<&'static str> = ::phf::Set { 972 | map: ::phf::Map { 973 | key: 16287231350648472473, 974 | disps: &[(0, 0)], 975 | entries: &[("merge", ())], 976 | }, 977 | }; 978 | 979 | pub(crate) static MOCK_STEM: phf::Set<&'static str> = ::phf::Set { 980 | map: ::phf::Map { 981 | key: 16287231350648472473, 982 | disps: &[(0, 0)], 983 | entries: &[("mock", ())], 984 | }, 985 | }; 986 | 987 | pub(crate) static MODIFI_STEM: phf::Set<&'static str> = ::phf::Set { 988 | map: ::phf::Map { 989 | key: 16287231350648472473, 990 | disps: &[(0, 0)], 991 | entries: &[("modify", ())], 992 | }, 993 | }; 994 | 995 | pub(crate) static MONITOR_STEM: phf::Set<&'static str> = ::phf::Set { 996 | map: ::phf::Map { 997 | key: 16287231350648472473, 998 | disps: &[(0, 0)], 999 | entries: &[("monitor", ())], 1000 | }, 1001 | }; 1002 | 1003 | pub(crate) static MOVE_STEM: phf::Set<&'static str> = ::phf::Set { 1004 | map: ::phf::Map { 1005 | key: 16287231350648472473, 1006 | disps: &[(0, 0)], 1007 | entries: &[("move", ())], 1008 | }, 1009 | }; 1010 | 1011 | pub(crate) static NORMAL_STEM: phf::Set<&'static str> = ::phf::Set { 1012 | map: ::phf::Map { 1013 | key: 16287231350648472473, 1014 | disps: &[(0, 0)], 1015 | entries: &[("normalize", ())], 1016 | }, 1017 | }; 1018 | 1019 | pub(crate) static NOTE_STEM: phf::Set<&'static str> = ::phf::Set { 1020 | map: ::phf::Map { 1021 | key: 16287231350648472473, 1022 | disps: &[(0, 0)], 1023 | entries: &[("note", ())], 1024 | }, 1025 | }; 1026 | 1027 | pub(crate) static OBTAIN_STEM: phf::Set<&'static str> = ::phf::Set { 1028 | map: ::phf::Map { 1029 | key: 16287231350648472473, 1030 | disps: &[(0, 0)], 1031 | entries: &[("obtain", ())], 1032 | }, 1033 | }; 1034 | 1035 | pub(crate) static OPEN_STEM: phf::Set<&'static str> = ::phf::Set { 1036 | map: ::phf::Map { 1037 | key: 16287231350648472473, 1038 | disps: &[(0, 0)], 1039 | entries: &[("open", ())], 1040 | }, 1041 | }; 1042 | 1043 | pub(crate) static OUTPUT_STEM: phf::Set<&'static str> = ::phf::Set { 1044 | map: ::phf::Map { 1045 | key: 16287231350648472473, 1046 | disps: &[(0, 0)], 1047 | entries: &[("output", ())], 1048 | }, 1049 | }; 1050 | 1051 | pub(crate) static OVERRID_STEM: phf::Set<&'static str> = ::phf::Set { 1052 | map: ::phf::Map { 1053 | key: 16287231350648472473, 1054 | disps: &[(0, 0)], 1055 | entries: &[("override", ())], 1056 | }, 1057 | }; 1058 | 1059 | pub(crate) static OVERWRIT_STEM: phf::Set<&'static str> = ::phf::Set { 1060 | map: ::phf::Map { 1061 | key: 16287231350648472473, 1062 | disps: &[(0, 0)], 1063 | entries: &[("overwrite", ())], 1064 | }, 1065 | }; 1066 | 1067 | pub(crate) static PACKAG_STEM: phf::Set<&'static str> = ::phf::Set { 1068 | map: ::phf::Map { 1069 | key: 16287231350648472473, 1070 | disps: &[(0, 0)], 1071 | entries: &[("package", ())], 1072 | }, 1073 | }; 1074 | 1075 | pub(crate) static PAD_STEM: phf::Set<&'static str> = ::phf::Set { 1076 | map: ::phf::Map { 1077 | key: 16287231350648472473, 1078 | disps: &[(0, 0)], 1079 | entries: &[("pad", ())], 1080 | }, 1081 | }; 1082 | 1083 | pub(crate) static PARS_STEM: phf::Set<&'static str> = ::phf::Set { 1084 | map: ::phf::Map { 1085 | key: 16287231350648472473, 1086 | disps: &[(0, 0)], 1087 | entries: &[("parse", ())], 1088 | }, 1089 | }; 1090 | 1091 | pub(crate) static PARTIAL_STEM: phf::Set<&'static str> = ::phf::Set { 1092 | map: ::phf::Map { 1093 | key: 16287231350648472473, 1094 | disps: &[(0, 0)], 1095 | entries: &[("partial", ())], 1096 | }, 1097 | }; 1098 | 1099 | pub(crate) static PASS_STEM: phf::Set<&'static str> = ::phf::Set { 1100 | map: ::phf::Map { 1101 | key: 16287231350648472473, 1102 | disps: &[(0, 0)], 1103 | entries: &[("pass", ())], 1104 | }, 1105 | }; 1106 | 1107 | pub(crate) static PERFORM_STEM: phf::Set<&'static str> = ::phf::Set { 1108 | map: ::phf::Map { 1109 | key: 16287231350648472473, 1110 | disps: &[(0, 0)], 1111 | entries: &[("perform", ())], 1112 | }, 1113 | }; 1114 | 1115 | pub(crate) static PERSIST_STEM: phf::Set<&'static str> = ::phf::Set { 1116 | map: ::phf::Map { 1117 | key: 16287231350648472473, 1118 | disps: &[(0, 0)], 1119 | entries: &[("persist", ())], 1120 | }, 1121 | }; 1122 | 1123 | pub(crate) static PICK_STEM: phf::Set<&'static str> = ::phf::Set { 1124 | map: ::phf::Map { 1125 | key: 16287231350648472473, 1126 | disps: &[(0, 0)], 1127 | entries: &[("pick", ())], 1128 | }, 1129 | }; 1130 | 1131 | pub(crate) static PLOT_STEM: phf::Set<&'static str> = ::phf::Set { 1132 | map: ::phf::Map { 1133 | key: 16287231350648472473, 1134 | disps: &[(0, 0)], 1135 | entries: &[("plot", ())], 1136 | }, 1137 | }; 1138 | 1139 | pub(crate) static POLL_STEM: phf::Set<&'static str> = ::phf::Set { 1140 | map: ::phf::Map { 1141 | key: 16287231350648472473, 1142 | disps: &[(0, 0)], 1143 | entries: &[("poll", ())], 1144 | }, 1145 | }; 1146 | 1147 | pub(crate) static POPUL_STEM: phf::Set<&'static str> = ::phf::Set { 1148 | map: ::phf::Map { 1149 | key: 16287231350648472473, 1150 | disps: &[(0, 0)], 1151 | entries: &[("populate", ())], 1152 | }, 1153 | }; 1154 | 1155 | pub(crate) static POST_STEM: phf::Set<&'static str> = ::phf::Set { 1156 | map: ::phf::Map { 1157 | key: 16287231350648472473, 1158 | disps: &[(0, 0)], 1159 | entries: &[("post", ())], 1160 | }, 1161 | }; 1162 | 1163 | pub(crate) static PREPAR_STEM: phf::Set<&'static str> = ::phf::Set { 1164 | map: ::phf::Map { 1165 | key: 16287231350648472473, 1166 | disps: &[(0, 0)], 1167 | entries: &[("prepare", ())], 1168 | }, 1169 | }; 1170 | 1171 | pub(crate) static PRINT_STEM: phf::Set<&'static str> = ::phf::Set { 1172 | map: ::phf::Map { 1173 | key: 16287231350648472473, 1174 | disps: &[(0, 0)], 1175 | entries: &[("print", ())], 1176 | }, 1177 | }; 1178 | 1179 | pub(crate) static PROCESS_STEM: phf::Set<&'static str> = ::phf::Set { 1180 | map: ::phf::Map { 1181 | key: 16287231350648472473, 1182 | disps: &[(0, 0)], 1183 | entries: &[("process", ())], 1184 | }, 1185 | }; 1186 | 1187 | pub(crate) static PRODUC_STEM: phf::Set<&'static str> = ::phf::Set { 1188 | map: ::phf::Map { 1189 | key: 16287231350648472473, 1190 | disps: &[(0, 0)], 1191 | entries: &[("produce", ())], 1192 | }, 1193 | }; 1194 | 1195 | pub(crate) static PROVID_STEM: phf::Set<&'static str> = ::phf::Set { 1196 | map: ::phf::Map { 1197 | key: 16287231350648472473, 1198 | disps: &[(0, 0)], 1199 | entries: &[("provide", ())], 1200 | }, 1201 | }; 1202 | 1203 | pub(crate) static PUBLISH_STEM: phf::Set<&'static str> = ::phf::Set { 1204 | map: ::phf::Map { 1205 | key: 16287231350648472473, 1206 | disps: &[(0, 0)], 1207 | entries: &[("publish", ())], 1208 | }, 1209 | }; 1210 | 1211 | pub(crate) static PULL_STEM: phf::Set<&'static str> = ::phf::Set { 1212 | map: ::phf::Map { 1213 | key: 16287231350648472473, 1214 | disps: &[(0, 0)], 1215 | entries: &[("pull", ())], 1216 | }, 1217 | }; 1218 | 1219 | pub(crate) static PUT_STEM: phf::Set<&'static str> = ::phf::Set { 1220 | map: ::phf::Map { 1221 | key: 16287231350648472473, 1222 | disps: &[(0, 0)], 1223 | entries: &[("put", ())], 1224 | }, 1225 | }; 1226 | 1227 | pub(crate) static QUERI_STEM: phf::Set<&'static str> = ::phf::Set { 1228 | map: ::phf::Map { 1229 | key: 16287231350648472473, 1230 | disps: &[(0, 0)], 1231 | entries: &[("query", ())], 1232 | }, 1233 | }; 1234 | 1235 | pub(crate) static RAIS_STEM: phf::Set<&'static str> = ::phf::Set { 1236 | map: ::phf::Map { 1237 | key: 16287231350648472473, 1238 | disps: &[(0, 0)], 1239 | entries: &[("raise", ())], 1240 | }, 1241 | }; 1242 | 1243 | pub(crate) static READ_STEM: phf::Set<&'static str> = ::phf::Set { 1244 | map: ::phf::Map { 1245 | key: 16287231350648472473, 1246 | disps: &[(0, 0)], 1247 | entries: &[("read", ())], 1248 | }, 1249 | }; 1250 | 1251 | pub(crate) static RECORD_STEM: phf::Set<&'static str> = ::phf::Set { 1252 | map: ::phf::Map { 1253 | key: 16287231350648472473, 1254 | disps: &[(0, 0)], 1255 | entries: &[("record", ())], 1256 | }, 1257 | }; 1258 | 1259 | pub(crate) static REFER_STEM: phf::Set<&'static str> = ::phf::Set { 1260 | map: ::phf::Map { 1261 | key: 16287231350648472473, 1262 | disps: &[(0, 0)], 1263 | entries: &[("refer", ())], 1264 | }, 1265 | }; 1266 | 1267 | pub(crate) static REFRESH_STEM: phf::Set<&'static str> = ::phf::Set { 1268 | map: ::phf::Map { 1269 | key: 16287231350648472473, 1270 | disps: &[(0, 0)], 1271 | entries: &[("refresh", ())], 1272 | }, 1273 | }; 1274 | 1275 | pub(crate) static REGIST_STEM: phf::Set<&'static str> = ::phf::Set { 1276 | map: ::phf::Map { 1277 | key: 16287231350648472473, 1278 | disps: &[(0, 0)], 1279 | entries: &[("register", ())], 1280 | }, 1281 | }; 1282 | 1283 | pub(crate) static RELOAD_STEM: phf::Set<&'static str> = ::phf::Set { 1284 | map: ::phf::Map { 1285 | key: 16287231350648472473, 1286 | disps: &[(0, 0)], 1287 | entries: &[("reload", ())], 1288 | }, 1289 | }; 1290 | 1291 | pub(crate) static REMOV_STEM: phf::Set<&'static str> = ::phf::Set { 1292 | map: ::phf::Map { 1293 | key: 16287231350648472473, 1294 | disps: &[(0, 0)], 1295 | entries: &[("remove", ())], 1296 | }, 1297 | }; 1298 | 1299 | pub(crate) static RENAM_STEM: phf::Set<&'static str> = ::phf::Set { 1300 | map: ::phf::Map { 1301 | key: 16287231350648472473, 1302 | disps: &[(0, 0)], 1303 | entries: &[("rename", ())], 1304 | }, 1305 | }; 1306 | 1307 | pub(crate) static RENDER_STEM: phf::Set<&'static str> = ::phf::Set { 1308 | map: ::phf::Map { 1309 | key: 16287231350648472473, 1310 | disps: &[(0, 0)], 1311 | entries: &[("render", ())], 1312 | }, 1313 | }; 1314 | 1315 | pub(crate) static REPLAC_STEM: phf::Set<&'static str> = ::phf::Set { 1316 | map: ::phf::Map { 1317 | key: 16287231350648472473, 1318 | disps: &[(0, 0)], 1319 | entries: &[("replace", ())], 1320 | }, 1321 | }; 1322 | 1323 | pub(crate) static REPLI_STEM: phf::Set<&'static str> = ::phf::Set { 1324 | map: ::phf::Map { 1325 | key: 16287231350648472473, 1326 | disps: &[(0, 0)], 1327 | entries: &[("reply", ())], 1328 | }, 1329 | }; 1330 | 1331 | pub(crate) static REPORT_STEM: phf::Set<&'static str> = ::phf::Set { 1332 | map: ::phf::Map { 1333 | key: 16287231350648472473, 1334 | disps: &[(0, 0)], 1335 | entries: &[("report", ())], 1336 | }, 1337 | }; 1338 | 1339 | pub(crate) static REPRES_STEM: phf::Set<&'static str> = ::phf::Set { 1340 | map: ::phf::Map { 1341 | key: 16287231350648472473, 1342 | disps: &[(0, 0)], 1343 | entries: &[("represent", ())], 1344 | }, 1345 | }; 1346 | 1347 | pub(crate) static REQUEST_STEM: phf::Set<&'static str> = ::phf::Set { 1348 | map: ::phf::Map { 1349 | key: 16287231350648472473, 1350 | disps: &[(0, 0)], 1351 | entries: &[("request", ())], 1352 | }, 1353 | }; 1354 | 1355 | pub(crate) static REQUIR_STEM: phf::Set<&'static str> = ::phf::Set { 1356 | map: ::phf::Map { 1357 | key: 16287231350648472473, 1358 | disps: &[(0, 0)], 1359 | entries: &[("require", ())], 1360 | }, 1361 | }; 1362 | 1363 | pub(crate) static RESET_STEM: phf::Set<&'static str> = ::phf::Set { 1364 | map: ::phf::Map { 1365 | key: 16287231350648472473, 1366 | disps: &[(0, 0)], 1367 | entries: &[("reset", ())], 1368 | }, 1369 | }; 1370 | 1371 | pub(crate) static RESOLV_STEM: phf::Set<&'static str> = ::phf::Set { 1372 | map: ::phf::Map { 1373 | key: 16287231350648472473, 1374 | disps: &[(0, 0)], 1375 | entries: &[("resolve", ())], 1376 | }, 1377 | }; 1378 | 1379 | pub(crate) static RETRIEV_STEM: phf::Set<&'static str> = ::phf::Set { 1380 | map: ::phf::Map { 1381 | key: 16287231350648472473, 1382 | disps: &[(0, 0)], 1383 | entries: &[("retrieve", ())], 1384 | }, 1385 | }; 1386 | 1387 | pub(crate) static RETURN_STEM: phf::Set<&'static str> = ::phf::Set { 1388 | map: ::phf::Map { 1389 | key: 16287231350648472473, 1390 | disps: &[(0, 0)], 1391 | entries: &[("return", ())], 1392 | }, 1393 | }; 1394 | 1395 | pub(crate) static ROLL_STEM: phf::Set<&'static str> = ::phf::Set { 1396 | map: ::phf::Map { 1397 | key: 16287231350648472473, 1398 | disps: &[(0, 0)], 1399 | entries: &[("roll", ())], 1400 | }, 1401 | }; 1402 | 1403 | pub(crate) static ROLLBACK_STEM: phf::Set<&'static str> = ::phf::Set { 1404 | map: ::phf::Map { 1405 | key: 16287231350648472473, 1406 | disps: &[(0, 0)], 1407 | entries: &[("rollback", ())], 1408 | }, 1409 | }; 1410 | 1411 | pub(crate) static ROUND_STEM: phf::Set<&'static str> = ::phf::Set { 1412 | map: ::phf::Map { 1413 | key: 16287231350648472473, 1414 | disps: &[(0, 0)], 1415 | entries: &[("round", ())], 1416 | }, 1417 | }; 1418 | 1419 | pub(crate) static RUN_STEM: phf::Set<&'static str> = ::phf::Set { 1420 | map: ::phf::Map { 1421 | key: 16287231350648472473, 1422 | disps: &[(0, 0)], 1423 | entries: &[("run", ())], 1424 | }, 1425 | }; 1426 | 1427 | pub(crate) static SAMPL_STEM: phf::Set<&'static str> = ::phf::Set { 1428 | map: ::phf::Map { 1429 | key: 16287231350648472473, 1430 | disps: &[(0, 0)], 1431 | entries: &[("sample", ())], 1432 | }, 1433 | }; 1434 | 1435 | pub(crate) static SAVE_STEM: phf::Set<&'static str> = ::phf::Set { 1436 | map: ::phf::Map { 1437 | key: 16287231350648472473, 1438 | disps: &[(0, 0)], 1439 | entries: &[("save", ())], 1440 | }, 1441 | }; 1442 | 1443 | pub(crate) static SCAN_STEM: phf::Set<&'static str> = ::phf::Set { 1444 | map: ::phf::Map { 1445 | key: 16287231350648472473, 1446 | disps: &[(0, 0)], 1447 | entries: &[("scan", ())], 1448 | }, 1449 | }; 1450 | 1451 | pub(crate) static SEARCH_STEM: phf::Set<&'static str> = ::phf::Set { 1452 | map: ::phf::Map { 1453 | key: 16287231350648472473, 1454 | disps: &[(0, 0)], 1455 | entries: &[("search", ())], 1456 | }, 1457 | }; 1458 | 1459 | pub(crate) static SELECT_STEM: phf::Set<&'static str> = ::phf::Set { 1460 | map: ::phf::Map { 1461 | key: 16287231350648472473, 1462 | disps: &[(0, 0)], 1463 | entries: &[("select", ())], 1464 | }, 1465 | }; 1466 | 1467 | pub(crate) static SEND_STEM: phf::Set<&'static str> = ::phf::Set { 1468 | map: ::phf::Map { 1469 | key: 16287231350648472473, 1470 | disps: &[(0, 0)], 1471 | entries: &[("send", ())], 1472 | }, 1473 | }; 1474 | 1475 | pub(crate) static SERIAL_STEM: phf::Set<&'static str> = ::phf::Set { 1476 | map: ::phf::Map { 1477 | key: 16287231350648472473, 1478 | disps: &[(0, 0)], 1479 | entries: &[("serialize", ())], 1480 | }, 1481 | }; 1482 | 1483 | pub(crate) static SERIALIS_STEM: phf::Set<&'static str> = ::phf::Set { 1484 | map: ::phf::Map { 1485 | key: 16287231350648472473, 1486 | disps: &[(0, 0)], 1487 | entries: &[("serialise", ())], 1488 | }, 1489 | }; 1490 | 1491 | pub(crate) static SERV_STEM: phf::Set<&'static str> = ::phf::Set { 1492 | map: ::phf::Map { 1493 | key: 16287231350648472473, 1494 | disps: &[(0, 0)], 1495 | entries: &[("serve", ())], 1496 | }, 1497 | }; 1498 | 1499 | pub(crate) static SET_STEM: phf::Set<&'static str> = ::phf::Set { 1500 | map: ::phf::Map { 1501 | key: 16287231350648472473, 1502 | disps: &[(0, 0)], 1503 | entries: &[("set", ())], 1504 | }, 1505 | }; 1506 | 1507 | pub(crate) static SHOW_STEM: phf::Set<&'static str> = ::phf::Set { 1508 | map: ::phf::Map { 1509 | key: 16287231350648472473, 1510 | disps: &[(0, 0)], 1511 | entries: &[("show", ())], 1512 | }, 1513 | }; 1514 | 1515 | pub(crate) static SIMUL_STEM: phf::Set<&'static str> = ::phf::Set { 1516 | map: ::phf::Map { 1517 | key: 16287231350648472473, 1518 | disps: &[(0, 0)], 1519 | entries: &[("simulate", ())], 1520 | }, 1521 | }; 1522 | 1523 | pub(crate) static SOURC_STEM: phf::Set<&'static str> = ::phf::Set { 1524 | map: ::phf::Map { 1525 | key: 16287231350648472473, 1526 | disps: &[(0, 0)], 1527 | entries: &[("source", ())], 1528 | }, 1529 | }; 1530 | 1531 | pub(crate) static SPECIFI_STEM: phf::Set<&'static str> = ::phf::Set { 1532 | map: ::phf::Map { 1533 | key: 16287231350648472473, 1534 | disps: &[(0, 0)], 1535 | entries: &[("specify", ())], 1536 | }, 1537 | }; 1538 | 1539 | pub(crate) static SPLIT_STEM: phf::Set<&'static str> = ::phf::Set { 1540 | map: ::phf::Map { 1541 | key: 16287231350648472473, 1542 | disps: &[(0, 0)], 1543 | entries: &[("split", ())], 1544 | }, 1545 | }; 1546 | 1547 | pub(crate) static START_STEM: phf::Set<&'static str> = ::phf::Set { 1548 | map: ::phf::Map { 1549 | key: 16287231350648472473, 1550 | disps: &[(0, 0)], 1551 | entries: &[("start", ())], 1552 | }, 1553 | }; 1554 | 1555 | pub(crate) static STEP_STEM: phf::Set<&'static str> = ::phf::Set { 1556 | map: ::phf::Map { 1557 | key: 16287231350648472473, 1558 | disps: &[(0, 0)], 1559 | entries: &[("step", ())], 1560 | }, 1561 | }; 1562 | 1563 | pub(crate) static STOP_STEM: phf::Set<&'static str> = ::phf::Set { 1564 | map: ::phf::Map { 1565 | key: 16287231350648472473, 1566 | disps: &[(0, 0)], 1567 | entries: &[("stop", ())], 1568 | }, 1569 | }; 1570 | 1571 | pub(crate) static STORE_STEM: phf::Set<&'static str> = ::phf::Set { 1572 | map: ::phf::Map { 1573 | key: 16287231350648472473, 1574 | disps: &[(0, 0)], 1575 | entries: &[("store", ())], 1576 | }, 1577 | }; 1578 | 1579 | pub(crate) static STRIP_STEM: phf::Set<&'static str> = ::phf::Set { 1580 | map: ::phf::Map { 1581 | key: 16287231350648472473, 1582 | disps: &[(0, 0)], 1583 | entries: &[("strip", ())], 1584 | }, 1585 | }; 1586 | 1587 | pub(crate) static SUBMIT_STEM: phf::Set<&'static str> = ::phf::Set { 1588 | map: ::phf::Map { 1589 | key: 16287231350648472473, 1590 | disps: &[(0, 0)], 1591 | entries: &[("submit", ())], 1592 | }, 1593 | }; 1594 | 1595 | pub(crate) static SUBSCRIB_STEM: phf::Set<&'static str> = ::phf::Set { 1596 | map: ::phf::Map { 1597 | key: 16287231350648472473, 1598 | disps: &[(0, 0)], 1599 | entries: &[("subscribe", ())], 1600 | }, 1601 | }; 1602 | 1603 | pub(crate) static SUM_STEM: phf::Set<&'static str> = ::phf::Set { 1604 | map: ::phf::Map { 1605 | key: 16287231350648472473, 1606 | disps: &[(0, 0)], 1607 | entries: &[("sum", ())], 1608 | }, 1609 | }; 1610 | 1611 | pub(crate) static SWAP_STEM: phf::Set<&'static str> = ::phf::Set { 1612 | map: ::phf::Map { 1613 | key: 16287231350648472473, 1614 | disps: &[(0, 0)], 1615 | entries: &[("swap", ())], 1616 | }, 1617 | }; 1618 | 1619 | pub(crate) static SYNC_STEM: phf::Set<&'static str> = ::phf::Set { 1620 | map: ::phf::Map { 1621 | key: 16287231350648472473, 1622 | disps: &[(0, 0)], 1623 | entries: &[("sync", ())], 1624 | }, 1625 | }; 1626 | 1627 | pub(crate) static SYNCHRON_STEM: phf::Set<&'static str> = ::phf::Set { 1628 | map: ::phf::Map { 1629 | key: 16287231350648472473, 1630 | disps: &[(0, 0)], 1631 | entries: &[("synchronize", ())], 1632 | }, 1633 | }; 1634 | 1635 | pub(crate) static SYNCHRONIS_STEM: phf::Set<&'static str> = ::phf::Set { 1636 | map: ::phf::Map { 1637 | key: 16287231350648472473, 1638 | disps: &[(0, 0)], 1639 | entries: &[("synchronise", ())], 1640 | }, 1641 | }; 1642 | 1643 | pub(crate) static TAKE_STEM: phf::Set<&'static str> = ::phf::Set { 1644 | map: ::phf::Map { 1645 | key: 16287231350648472473, 1646 | disps: &[(0, 0)], 1647 | entries: &[("take", ())], 1648 | }, 1649 | }; 1650 | 1651 | pub(crate) static TEAR_STEM: phf::Set<&'static str> = ::phf::Set { 1652 | map: ::phf::Map { 1653 | key: 16287231350648472473, 1654 | disps: &[(0, 0)], 1655 | entries: &[("tear", ())], 1656 | }, 1657 | }; 1658 | 1659 | pub(crate) static TEST_STEM: phf::Set<&'static str> = ::phf::Set { 1660 | map: ::phf::Map { 1661 | key: 16287231350648472473, 1662 | disps: &[(0, 0)], 1663 | entries: &[("test", ())], 1664 | }, 1665 | }; 1666 | 1667 | pub(crate) static TIME_STEM: phf::Set<&'static str> = ::phf::Set { 1668 | map: ::phf::Map { 1669 | key: 16287231350648472473, 1670 | disps: &[(0, 0)], 1671 | entries: &[("time", ())], 1672 | }, 1673 | }; 1674 | 1675 | pub(crate) static TRANSFORM_STEM: phf::Set<&'static str> = ::phf::Set { 1676 | map: ::phf::Map { 1677 | key: 16287231350648472473, 1678 | disps: &[(0, 0)], 1679 | entries: &[("transform", ())], 1680 | }, 1681 | }; 1682 | 1683 | pub(crate) static TRANSLAT_STEM: phf::Set<&'static str> = ::phf::Set { 1684 | map: ::phf::Map { 1685 | key: 16287231350648472473, 1686 | disps: &[(0, 0)], 1687 | entries: &[("translate", ())], 1688 | }, 1689 | }; 1690 | 1691 | pub(crate) static TRANSMIT_STEM: phf::Set<&'static str> = ::phf::Set { 1692 | map: ::phf::Map { 1693 | key: 16287231350648472473, 1694 | disps: &[(0, 0)], 1695 | entries: &[("transmit", ())], 1696 | }, 1697 | }; 1698 | 1699 | pub(crate) static TRI_STEM: phf::Set<&'static str> = ::phf::Set { 1700 | map: ::phf::Map { 1701 | key: 16287231350648472473, 1702 | disps: &[(0, 0)], 1703 | entries: &[("try", ())], 1704 | }, 1705 | }; 1706 | 1707 | pub(crate) static TRUNCAT_STEM: phf::Set<&'static str> = ::phf::Set { 1708 | map: ::phf::Map { 1709 | key: 16287231350648472473, 1710 | disps: &[(0, 0)], 1711 | entries: &[("truncate", ())], 1712 | }, 1713 | }; 1714 | 1715 | pub(crate) static TURN_STEM: phf::Set<&'static str> = ::phf::Set { 1716 | map: ::phf::Map { 1717 | key: 16287231350648472473, 1718 | disps: &[(0, 0)], 1719 | entries: &[("turn", ())], 1720 | }, 1721 | }; 1722 | 1723 | pub(crate) static TWEAK_STEM: phf::Set<&'static str> = ::phf::Set { 1724 | map: ::phf::Map { 1725 | key: 16287231350648472473, 1726 | disps: &[(0, 0)], 1727 | entries: &[("tweak", ())], 1728 | }, 1729 | }; 1730 | 1731 | pub(crate) static UPDAT_STEM: phf::Set<&'static str> = ::phf::Set { 1732 | map: ::phf::Map { 1733 | key: 16287231350648472473, 1734 | disps: &[(0, 0)], 1735 | entries: &[("update", ())], 1736 | }, 1737 | }; 1738 | 1739 | pub(crate) static UPLOAD_STEM: phf::Set<&'static str> = ::phf::Set { 1740 | map: ::phf::Map { 1741 | key: 16287231350648472473, 1742 | disps: &[(0, 0)], 1743 | entries: &[("upload", ())], 1744 | }, 1745 | }; 1746 | 1747 | pub(crate) static USE_STEM: phf::Set<&'static str> = ::phf::Set { 1748 | map: ::phf::Map { 1749 | key: 16287231350648472473, 1750 | disps: &[(0, 0)], 1751 | entries: &[("use", ())], 1752 | }, 1753 | }; 1754 | 1755 | pub(crate) static VALID_STEM: phf::Set<&'static str> = ::phf::Set { 1756 | map: ::phf::Map { 1757 | key: 16287231350648472473, 1758 | disps: &[(0, 0)], 1759 | entries: &[("validate", ())], 1760 | }, 1761 | }; 1762 | 1763 | pub(crate) static VERIFI_STEM: phf::Set<&'static str> = ::phf::Set { 1764 | map: ::phf::Map { 1765 | key: 16287231350648472473, 1766 | disps: &[(0, 0)], 1767 | entries: &[("verify", ())], 1768 | }, 1769 | }; 1770 | 1771 | pub(crate) static VIEW_STEM: phf::Set<&'static str> = ::phf::Set { 1772 | map: ::phf::Map { 1773 | key: 16287231350648472473, 1774 | disps: &[(0, 0)], 1775 | entries: &[("view", ())], 1776 | }, 1777 | }; 1778 | 1779 | pub(crate) static WAIT_STEM: phf::Set<&'static str> = ::phf::Set { 1780 | map: ::phf::Map { 1781 | key: 16287231350648472473, 1782 | disps: &[(0, 0)], 1783 | entries: &[("wait", ())], 1784 | }, 1785 | }; 1786 | 1787 | pub(crate) static WALK_STEM: phf::Set<&'static str> = ::phf::Set { 1788 | map: ::phf::Map { 1789 | key: 16287231350648472473, 1790 | disps: &[(0, 0)], 1791 | entries: &[("walk", ())], 1792 | }, 1793 | }; 1794 | 1795 | pub(crate) static WRAP_STEM: phf::Set<&'static str> = ::phf::Set { 1796 | map: ::phf::Map { 1797 | key: 16287231350648472473, 1798 | disps: &[(0, 0)], 1799 | entries: &[("wrap", ())], 1800 | }, 1801 | }; 1802 | 1803 | pub(crate) static WRITE_STEM: phf::Set<&'static str> = ::phf::Set { 1804 | map: ::phf::Map { 1805 | key: 16287231350648472473, 1806 | disps: &[(0, 0)], 1807 | entries: &[("write", ())], 1808 | }, 1809 | }; 1810 | 1811 | pub(crate) static YIELD_STEM: phf::Set<&'static str> = ::phf::Set { 1812 | map: ::phf::Map { 1813 | key: 16287231350648472473, 1814 | disps: &[(0, 0)], 1815 | entries: &[("yield", ())], 1816 | }, 1817 | }; 1818 | 1819 | pub(crate) static IMPERATIVES: phf::Map<&'static str, &phf::Set<&'static str>> = ::phf::Map { 1820 | key: 16287231350648472473, 1821 | disps: &[ 1822 | (1, 135), 1823 | (20, 167), 1824 | (1, 9), 1825 | (0, 86), 1826 | (0, 25), 1827 | (0, 0), 1828 | (0, 7), 1829 | (0, 1), 1830 | (1, 16), 1831 | (0, 10), 1832 | (2, 84), 1833 | (0, 10), 1834 | (1, 2), 1835 | (0, 0), 1836 | (1, 52), 1837 | (0, 44), 1838 | (0, 8), 1839 | (0, 62), 1840 | (1, 73), 1841 | (0, 19), 1842 | (0, 127), 1843 | (1, 175), 1844 | (0, 8), 1845 | (6, 106), 1846 | (1, 15), 1847 | (4, 36), 1848 | (0, 3), 1849 | (1, 25), 1850 | (1, 12), 1851 | (18, 8), 1852 | (16, 124), 1853 | (0, 20), 1854 | (0, 1), 1855 | (0, 116), 1856 | (0, 223), 1857 | (5, 54), 1858 | (0, 17), 1859 | (0, 1), 1860 | (1, 173), 1861 | (5, 68), 1862 | (0, 8), 1863 | (0, 1), 1864 | (3, 114), 1865 | (5, 190), 1866 | (15, 112), 1867 | (68, 13), 1868 | ], 1869 | entries: &[ 1870 | ("pars", &PARS_STEM), 1871 | ("break", &BREAK_STEM), 1872 | ("remov", &REMOV_STEM), 1873 | ("group", &GROUP_STEM), 1874 | ("process", &PROCESS_STEM), 1875 | ("forc", &FORC_STEM), 1876 | ("copi", &COPI_STEM), 1877 | ("emit", &EMIT_STEM), 1878 | ("combin", &COMBIN_STEM), 1879 | ("close", &CLOSE_STEM), 1880 | ("resolv", &RESOLV_STEM), 1881 | ("invok", &INVOK_STEM), 1882 | ("final", &FINAL_STEM), 1883 | ("regist", ®IST_STEM), 1884 | ("load", &LOAD_STEM), 1885 | ("manag", &MANAG_STEM), 1886 | ("drop", &DROP_STEM), 1887 | ("configur", &CONFIGUR_STEM), 1888 | ("scan", &SCAN_STEM), 1889 | ("delet", &DELET_STEM), 1890 | ("extend", &EXTEND_STEM), 1891 | ("encapsul", &ENCAPSUL_STEM), 1892 | ("assert", &ASSERT_STEM), 1893 | ("give", &GIVE_STEM), 1894 | ("forward", &FORWARD_STEM), 1895 | ("end", &END_STEM), 1896 | ("commit", &COMMIT_STEM), 1897 | ("download", &DOWNLOAD_STEM), 1898 | ("feed", &FEED_STEM), 1899 | ("take", &TAKE_STEM), 1900 | ("list", &LIST_STEM), 1901 | ("upload", &UPLOAD_STEM), 1902 | ("tri", &TRI_STEM), 1903 | ("specifi", &SPECIFI_STEM), 1904 | ("refer", &REFER_STEM), 1905 | ("manipul", &MANIPUL_STEM), 1906 | ("persist", &PERSIST_STEM), 1907 | ("compar", &COMPAR_STEM), 1908 | ("make", &MAKE_STEM), 1909 | ("export", &EXPORT_STEM), 1910 | ("render", &RENDER_STEM), 1911 | ("import", &IMPORT_STEM), 1912 | ("encod", &ENCOD_STEM), 1913 | ("handl", &HANDL_STEM), 1914 | ("show", &SHOW_STEM), 1915 | ("confirm", &CONFIRM_STEM), 1916 | ("normal", &NORMAL_STEM), 1917 | ("view", &VIEW_STEM), 1918 | ("serial", &SERIAL_STEM), 1919 | ("prepar", &PREPAR_STEM), 1920 | ("decod", &DECOD_STEM), 1921 | ("split", &SPLIT_STEM), 1922 | ("simul", &SIMUL_STEM), 1923 | ("appli", &APPLI_STEM), 1924 | ("produc", &PRODUC_STEM), 1925 | ("transmit", &TRANSMIT_STEM), 1926 | ("collect", &COLLECT_STEM), 1927 | ("tweak", &TWEAK_STEM), 1928 | ("adjust", &ADJUST_STEM), 1929 | ("test", &TEST_STEM), 1930 | ("call", &CALL_STEM), 1931 | ("refresh", &REFRESH_STEM), 1932 | ("convert", &CONVERT_STEM), 1933 | ("examin", &EXAMIN_STEM), 1934 | ("build", &BUILD_STEM), 1935 | ("merg", &MERG_STEM), 1936 | ("reset", &RESET_STEM), 1937 | ("stop", &STOP_STEM), 1938 | ("fill", &FILL_STEM), 1939 | ("connect", &CONNECT_STEM), 1940 | ("append", &APPEND_STEM), 1941 | ("walk", &WALK_STEM), 1942 | ("serialis", &SERIALIS_STEM), 1943 | ("captur", &CAPTUR_STEM), 1944 | ("look", &LOOK_STEM), 1945 | ("swap", &SWAP_STEM), 1946 | ("go", &GO_STEM), 1947 | ("round", &ROUND_STEM), 1948 | ("calcul", &CALCUL_STEM), 1949 | ("check", &CHECK_STEM), 1950 | ("mark", &MARK_STEM), 1951 | ("time", &TIME_STEM), 1952 | ("empti", &EMPTI_STEM), 1953 | ("author", &AUTHOR_STEM), 1954 | ("filter", &FILTER_STEM), 1955 | ("enabl", &ENABL_STEM), 1956 | ("chang", &CHANG_STEM), 1957 | ("clear", &CLEAR_STEM), 1958 | ("provid", &PROVID_STEM), 1959 | ("construct", &CONSTRUCT_STEM), 1960 | ("help", &HELP_STEM), 1961 | ("yield", &YIELD_STEM), 1962 | ("note", &NOTE_STEM), 1963 | ("plot", &PLOT_STEM), 1964 | ("format", &FORMAT_STEM), 1965 | ("queri", &QUERI_STEM), 1966 | ("ensur", &ENSUR_STEM), 1967 | ("implement", &IMPLEMENT_STEM), 1968 | ("hold", &HOLD_STEM), 1969 | ("extract", &EXTRACT_STEM), 1970 | ("insert", &INSERT_STEM), 1971 | ("wrap", &WRAP_STEM), 1972 | ("valid", &VALID_STEM), 1973 | ("pad", &PAD_STEM), 1974 | ("write", &WRITE_STEM), 1975 | ("perform", &PERFORM_STEM), 1976 | ("iter", &ITER_STEM), 1977 | ("modifi", &MODIFI_STEM), 1978 | ("publish", &PUBLISH_STEM), 1979 | ("rais", &RAIS_STEM), 1980 | ("pull", &PULL_STEM), 1981 | ("flag", &FLAG_STEM), 1982 | ("enumer", &ENUMER_STEM), 1983 | ("add", &ADD_STEM), 1984 | ("requir", &REQUIR_STEM), 1985 | ("deprec", &DEPREC_STEM), 1986 | ("report", &REPORT_STEM), 1987 | ("init", &INIT_STEM), 1988 | ("fetch", &FETCH_STEM), 1989 | ("log", &LOG_STEM), 1990 | ("display", &DISPLAY_STEM), 1991 | ("renam", &RENAM_STEM), 1992 | ("post", &POST_STEM), 1993 | ("serv", &SERV_STEM), 1994 | ("join", &JOIN_STEM), 1995 | ("reload", &RELOAD_STEM), 1996 | ("access", &ACCESS_STEM), 1997 | ("store", &STORE_STEM), 1998 | ("custom", &CUSTOM_STEM), 1999 | ("detect", &DETECT_STEM), 2000 | ("wait", &WAIT_STEM), 2001 | ("output", &OUTPUT_STEM), 2002 | ("clean", &CLEAN_STEM), 2003 | ("updat", &UPDAT_STEM), 2004 | ("aggreg", &AGGREG_STEM), 2005 | ("return", &RETURN_STEM), 2006 | ("initialis", &INITIALIS_STEM), 2007 | ("assign", &ASSIGN_STEM), 2008 | ("sum", &SUM_STEM), 2009 | ("record", &RECORD_STEM), 2010 | ("allow", &ALLOW_STEM), 2011 | ("control", &CONTROL_STEM), 2012 | ("select", &SELECT_STEM), 2013 | ("search", &SEARCH_STEM), 2014 | ("keep", &KEEP_STEM), 2015 | ("save", &SAVE_STEM), 2016 | ("request", &REQUEST_STEM), 2017 | ("determin", &DETERMIN_STEM), 2018 | ("pass", &PASS_STEM), 2019 | ("sync", &SYNC_STEM), 2020 | ("fix", &FIX_STEM), 2021 | ("establish", &ESTABLISH_STEM), 2022 | ("instanti", &INSTANTI_STEM), 2023 | ("roll", &ROLL_STEM), 2024 | ("evalu", &EVALU_STEM), 2025 | ("declar", &DECLAR_STEM), 2026 | ("deleg", &DELEG_STEM), 2027 | ("match", &MATCH_STEM), 2028 | ("retriev", &RETRIEV_STEM), 2029 | ("get", &GET_STEM), 2030 | ("comput", &COMPUT_STEM), 2031 | ("intercept", &INTERCEPT_STEM), 2032 | ("replac", &REPLAC_STEM), 2033 | ("read", &READ_STEM), 2034 | ("repli", &REPLI_STEM), 2035 | ("sourc", &SOURC_STEM), 2036 | ("decor", &DECOR_STEM), 2037 | ("deriv", &DERIV_STEM), 2038 | ("attempt", &ATTEMPT_STEM), 2039 | ("cach", &CACH_STEM), 2040 | ("put", &PUT_STEM), 2041 | ("set", &SET_STEM), 2042 | ("launch", &LAUNCH_STEM), 2043 | ("accept", &ACCEPT_STEM), 2044 | ("pick", &PICK_STEM), 2045 | ("find", &FIND_STEM), 2046 | ("cancel", &CANCEL_STEM), 2047 | ("initi", &INITI_STEM), 2048 | ("obtain", &OBTAIN_STEM), 2049 | ("synchronis", &SYNCHRONIS_STEM), 2050 | ("overrid", &OVERRID_STEM), 2051 | ("subscrib", &SUBSCRIB_STEM), 2052 | ("generat", &GENERAT_STEM), 2053 | ("indic", &INDIC_STEM), 2054 | ("print", &PRINT_STEM), 2055 | ("overwrit", &OVERWRIT_STEM), 2056 | ("tear", &TEAR_STEM), 2057 | ("turn", &TURN_STEM), 2058 | ("archiv", &ARCHIV_STEM), 2059 | ("count", &COUNT_STEM), 2060 | ("rollback", &ROLLBACK_STEM), 2061 | ("step", &STEP_STEM), 2062 | ("describ", &DESCRIB_STEM), 2063 | ("repres", &REPRES_STEM), 2064 | ("poll", &POLL_STEM), 2065 | ("sampl", &SAMPL_STEM), 2066 | ("identifi", &IDENTIFI_STEM), 2067 | ("transform", &TRANSFORM_STEM), 2068 | ("expand", &EXPAND_STEM), 2069 | ("packag", &PACKAG_STEM), 2070 | ("open", &OPEN_STEM), 2071 | ("popul", &POPUL_STEM), 2072 | ("truncat", &TRUNCAT_STEM), 2073 | ("expect", &EXPECT_STEM), 2074 | ("verifi", &VERIFI_STEM), 2075 | ("use", &USE_STEM), 2076 | ("send", &SEND_STEM), 2077 | ("authent", &AUTHENT_STEM), 2078 | ("mock", &MOCK_STEM), 2079 | ("input", &INPUT_STEM), 2080 | ("translat", &TRANSLAT_STEM), 2081 | ("creat", &CREAT_STEM), 2082 | ("run", &RUN_STEM), 2083 | ("listen", &LISTEN_STEM), 2084 | ("fire", &FIRE_STEM), 2085 | ("monitor", &MONITOR_STEM), 2086 | ("submit", &SUBMIT_STEM), 2087 | ("strip", &STRIP_STEM), 2088 | ("synchron", &SYNCHRON_STEM), 2089 | ("exit", &EXIT_STEM), 2090 | ("move", &MOVE_STEM), 2091 | ("partial", &PARTIAL_STEM), 2092 | ("start", &START_STEM), 2093 | ("map", &MAP_STEM), 2094 | ("execut", &EXECUT_STEM), 2095 | ("dump", &DUMP_STEM), 2096 | ("defin", &DEFIN_STEM), 2097 | ], 2098 | }; 2099 | pub(crate) static BLACKLIST: phf::Set<&'static str> = ::phf::Set { 2100 | map: ::phf::Map { 2101 | key: 16263683158343804936, 2102 | disps: &[ 2103 | (3, 41), 2104 | (1, 4), 2105 | (6, 36), 2106 | (0, 3), 2107 | (0, 57), 2108 | (4, 4), 2109 | (3, 47), 2110 | (1, 32), 2111 | (0, 55), 2112 | (0, 0), 2113 | (0, 6), 2114 | (0, 16), 2115 | (0, 0), 2116 | (0, 26), 2117 | (44, 45), 2118 | ], 2119 | entries: &[ 2120 | ("a", ()), 2121 | ("wrapper", ()), 2122 | ("base", ()), 2123 | ("should", ()), 2124 | ("collection", ()), 2125 | ("same", ()), 2126 | ("unit", ()), 2127 | ("here", ()), 2128 | ("api", ()), 2129 | ("the", ()), 2130 | ("optional", ()), 2131 | ("final", ()), 2132 | ("this", ()), 2133 | ("does", ()), 2134 | ("convenient", ()), 2135 | ("unique", ()), 2136 | ("that", ()), 2137 | ("constructor", ()), 2138 | ("special", ()), 2139 | ("business", ()), 2140 | ("number", ()), 2141 | ("placeholder", ()), 2142 | ("always", ()), 2143 | ("static", ()), 2144 | ("string", ()), 2145 | ("importantly", ()), 2146 | ("subclasses", ()), 2147 | ("hook", ()), 2148 | ("reference", ()), 2149 | ("true", ()), 2150 | ("it", ()), 2151 | ("function", ()), 2152 | ("description", ()), 2153 | ("internal", ()), 2154 | ("example", ()), 2155 | ("method", ()), 2156 | ("module", ()), 2157 | ("schema", ()), 2158 | ("standard", ()), 2159 | ("sql", ()), 2160 | ("default", ()), 2161 | ("simple", ()), 2162 | ("generic", ()), 2163 | ("custom", ()), 2164 | ("convenience", ()), 2165 | ("action", ()), 2166 | ("new", ()), 2167 | ("these", ()), 2168 | ("callback", ()), 2169 | ("helper", ()), 2170 | ("an", ()), 2171 | ("currently", ()), 2172 | ("formula", ()), 2173 | ("common", ()), 2174 | ("calculation", ()), 2175 | ("setup", ()), 2176 | ("some", ()), 2177 | ("data", ()), 2178 | ("basic", ()), 2179 | ("main", ()), 2180 | ("deprecated", ()), 2181 | ("false", ()), 2182 | ("implementation", ()), 2183 | ("dict", ()), 2184 | ("dummy", ()), 2185 | ("dictionary", ()), 2186 | ("current", ()), 2187 | ("utility", ()), 2188 | ("what", ()), 2189 | ("result", ()), 2190 | ("factory", ()), 2191 | ("handler", ()), 2192 | ], 2193 | }, 2194 | }; 2195 | --------------------------------------------------------------------------------