### Iterate over all scripts with Script::all()

Source: https://docs.rs/whatlang/latest/whatlang/enum.Script.html

Example usage of the all() method to iterate over all existing scripts and print them.

```rust
use whatlang::Script;
for script in Script::all() {
    println!("{}", script);
}
```

--------------------------------

### Detector struct implementation with allowlist and denylist examples

Source: https://docs.rs/whatlang/latest/src/whatlang/core/detector.rs.html

The full source code of the Detector struct, including constructors with_allowlist and with_denylist, and methods detect, detect_lang, and detect_script. The doc comments include examples for using with_allowlist and with_denylist. The code also includes unit tests for detect_script, detect_lang, and detect.

```rust
use crate::Lang;
use crate::core;
use crate::core::FilterList;
use crate::core::Info;
use crate::core::Options;
use crate::scripts::{Script, detect_script};

/// Configurable structure that holds detection options and provides functions
/// to detect language and script.
/// # Examples
/// Specifying an allowlist:
///
/// 
/// use whatlang::{Detector, Lang};
///
/// // Create detector with allowlist
/// let detector = Detector::with_allowlist(vec![Lang::Eng, Lang::Rus]);
/// let lang = detector.detect_lang("That is not Russian");
/// assert_eq!(lang, Some(Lang::Eng));
/// 
///
/// Specifying a blacklist:
///
/// 
/// use whatlang::{Detector, Lang};
///
/// let detector = Detector::with_denylist(vec![Lang::Eng, Lang::Ita]);
/// let lang = detector.detect_lang("Jen la trinkejo fermitis, ni iras tra mallumo kaj pluvo.");
/// assert_eq!(lang, Some(Lang::Epo));
/// 
#[cfg_attr(feature = "arbitrary", derive(::arbitrary::Arbitrary))]
#[derive(Debug, Clone, Default)]
pub struct Detector {
    options: Options,
}

impl Detector {
    pub fn new() -> Self {
        Self::default()
    }

    pub fn with_allowlist(list: Vec<Lang>) -> Self {
        let opts = Options::new().set_filter_list(FilterList::allow(list));
        Self::with_options(opts)
    }

    pub fn with_denylist(list: Vec<Lang>) -> Self {
        let opts = Options::new().set_filter_list(FilterList::deny(list));
        Self::with_options(opts)
    }

    fn with_options(options: Options) -> Self {
        Detector { options }
    }

    pub fn detect(&self, text: &str) -> Option<Info> {
        core::detect_with_options(text, &self.options)
    }

    pub fn detect_lang(&self, text: &str) -> Option<Lang> {
        core::detect_with_options(text, &self.options).map(|info| info.lang())
    }

    pub fn detect_script(&self, text: &str) -> Option<Script> {
        detect_script(text)
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_detect_script() {
        // Russian, Cyrillic
        assert_eq!(
            Detector::new().detect_script("Кириллица"),
            Some(Script::Cyrillic)
        );
    }

    #[test]
    fn test_detect_lang() {
        // Esperanto
        let text = "Ĉiuj redaktantoj de Esperanta Vikipedio estas volontuloj. Ili partoprenas en la kunlaborema komunumo, sen estro, kie la anoj kunordigas siajn strebojn kadre de temaj projektoj kaj pluraj diskutejoj. Ili sekvas la bazajn regulojn establitaj de la komunumo, ekzemple kontrolebleco de la informo aŭ la menciindeco de la temo.";
        assert_eq!(Detector::new().detect_lang(text), Some(Lang::Epo));
    }

    #[test]
    fn test_detect() {
        // Esperanto
        let text = "Ĉiuj redaktantoj de Esperanta Vikipedio estas volontuloj. Ili partoprenas en la kunlaborema komunumo, sen estro, kie la anoj kunordigas siajn strebojn kadre de temaj projektoj kaj pluraj diskutejoj. Ili sekvas la bazajn regulojn establitaj de la komunumo, ekzemple kontrolebleco de la informo aŭ la menciindeco de la temo.";
        let output = Detector::new().detect(text);
        assert_eq!(output.is_some(), true);

        let info = output.unwrap();
        assert_eq!(info.lang(), Lang::Epo);
        assert_eq!(info.script(), Script::Latin);
    }
}
```

--------------------------------

### Lang::all

Source: https://docs.rs/whatlang/latest/whatlang/enum.Lang.html

Gets all existing languages as a static slice of Lang.

```APIDOC
## Lang::all

### Description
Gets all existing languages as a static slice of Lang.

### Method
all

### Signature
pub fn all() -> &'static [Lang]

### Parameters
None

### Return Value
- **&'static [Lang]** - A slice containing all supported languages.

### Example
```rust
use whatlang::Lang;
for lang in Lang::all() {
    println!("{}", lang);
}
```
```

--------------------------------

### detect_lang function with example

Source: https://docs.rs/whatlang/latest/src/whatlang/core/detect.rs.html

Public function that detects only the language from a given text, returning Option<Lang>. The example shows usage with an English sentence and asserts the result is Lang::Eng.

```rust
pub fn detect_lang(text: &str) -> Option<Lang> {
    detect(text).map(|output| output.lang())
}
```

```rust
use whatlang::{detect_lang, Lang};
let lang = detect_lang("There is no reason not to learn Esperanto.").unwrap();
assert_eq!(lang, Lang::Eng);
```

--------------------------------

### Get English language name

Source: https://docs.rs/whatlang/latest/whatlang/enum.Lang.html

Returns the human-readable English name of the language. For example, Lang::Deu returns "German".

```rust
use whatlang::Lang;
assert_eq!(Lang::Deu.eng_name(), "German");
```

--------------------------------

### Info::new

Source: https://docs.rs/whatlang/latest/whatlang/struct.Info.html

Creates a new Info instance with the given script, language, and confidence.

```APIDOC
## Info::new

### Description
Creates a new `Info` instance with the specified script, language, and confidence.

### Method
`pub fn new(script: Script, lang: Lang, confidence: f64) -> Self`

### Parameters
- `script` (Script) - Required - The detected script.
- `lang` (Lang) - Required - The detected language.
- `confidence` (f64) - Required - The confidence score of the detection.

### Returns
- `Self` - A new `Info` instance.
```

--------------------------------

### Get language name in its own language

Source: https://docs.rs/whatlang/latest/whatlang/enum.Lang.html

Returns the language name in the language itself (endonym). For example, Lang::Ukr returns "Українська".

```rust
use whatlang::Lang;
assert_eq!(Lang::Ukr.name(), "Українська");
```

--------------------------------

### Lang::name

Source: https://docs.rs/whatlang/latest/whatlang/enum.Lang.html

Gets the language name in the language itself.

```APIDOC
## Lang::name

### Description
Gets the language name in the language itself.

### Method
name

### Signature
pub fn name(self) -> &'static str

### Parameters
- **self** - The Lang instance.

### Return Value
- **&'static str** - The language name in the language itself.

### Example
```rust
use whatlang::Lang;
assert_eq!(Lang::Ukr.name(), "Українська");
```
```

--------------------------------

### Specifying a denylist with Detector::with_denylist

Source: https://docs.rs/whatlang/latest/whatlang/struct.Detector.html

Creates a Detector with a denylist of English and Italian, then detects the language of an Esperanto phrase, expecting Esperanto.

```rust
use whatlang::{Detector, Lang};

let detector = Detector::with_denylist(vec![Lang::Eng, Lang::Ita]);
let lang = detector.detect_lang("Jen la trinkejo fermitis, ni iras tra mallumo kaj pluvo.");
assert_eq!(lang, Some(Lang::Epo));
```

--------------------------------

### Detector::new()

Source: https://docs.rs/whatlang/latest/src/whatlang/core/detector.rs.html

Creates a new Detector instance with default options.

```APIDOC
## Detector::new()

### Description
Creates a new Detector instance with default options.

### Method
Constructor

### Signature
```rust
pub fn new() -> Self
```

### Returns
- **Self** - A new Detector instance.

### Example
```rust
let detector = Detector::new();
```
```

--------------------------------

### Lang::eng_name

Source: https://docs.rs/whatlang/latest/whatlang/enum.Lang.html

Gets a human readable name of the language in English.

```APIDOC
## Lang::eng_name

### Description
Gets a human readable name of the language in English.

### Method
eng_name

### Signature
pub fn eng_name(self) -> &'static str

### Parameters
- **self** - The Lang instance.

### Return Value
- **&'static str** - The language name in English.

### Example
```rust
use whatlang::Lang;
assert_eq!(Lang::Deu.eng_name(), "German");
```
```

--------------------------------

### Detect language and script using detect function

Source: https://docs.rs/whatlang

Demonstrates basic usage of the detect function to identify the language and script of a given text string.

```rust
use whatlang::{detect, Lang, Script};

let text = "Ĉu vi ne volas eklerni Esperanton? Bonvolu! Estas unu de la plej bonaj aferoj!";
let info = detect(text).unwrap();
assert_eq!(info.lang(), Lang::Epo);
assert_eq!(info.script(), Script::Latin);

// Confidence is in the range from 0 to 1.
assert_eq!(info.confidence(), 1.0);
assert!(info.is_reliable());
```

--------------------------------

### detect_with_options function

Source: https://docs.rs/whatlang/latest/src/whatlang/core/detect.rs.html

Public function that detects language with custom options, constructing a Query and delegating to detect_by_query.

```rust
pub fn detect_with_options(text: &str, options: &Options) -> Option<Info> {
    let query = Query {
        text,
        filter_list: &options.filter_list,
        method: options.method,
    };
    detect_by_query(&query)
}
```

--------------------------------

### Lang::from_code

Source: https://docs.rs/whatlang/latest/whatlang/enum.Lang.html

Gets a Lang enum from an ISO 639-3 code as a string. Returns None if the code is not recognized.

```APIDOC
## Lang::from_code

### Description
Gets a Lang enum from an ISO 639-3 code as a string. Returns None if the code is not recognized.

### Method
from_code

### Signature
pub fn from_code<S: Into<String>>(code: S) -> Option<Lang>

### Parameters
- **code** (S: Into<String>) - Required - The ISO 639-3 code as a string.

### Return Value
- **Option<Lang>** - The corresponding Lang enum, or None if the code is not recognized.

### Example
```rust
use whatlang::Lang;
assert_eq!(Lang::from_code("ukr"), Some(Lang::Ukr));
```
```

--------------------------------

### Test Script::all() returns 25 scripts and contains Cyrillic, Arabic, Latin

Source: https://docs.rs/whatlang/latest/src/whatlang/scripts/script.rs.html

Verifies that Script::all() returns a list of 25 scripts and that it contains Cyrillic, Arabic, and Latin.

```rust
use super::*;

#[test]
fn test_all() {
    assert_eq!(Script::all().len(), 25);
    let all = Script::all();
    assert!(all.contains(&Script::Cyrillic));
    assert!(all.contains(&Script::Arabic));
    assert!(all.contains(&Script::Latin));
}
```

--------------------------------

### Detector::with_denylist

Source: https://docs.rs/whatlang

Creates a Detector with a denylist of languages to exclude during detection. This is an alternative to with_allowlist.

```APIDOC
## Detector::with_denylist

### Description
Creates a `Detector` with a specified denylist of languages. The detector will exclude the listed languages during detection.

### Function Signature
`pub fn with_denylist(langs: Vec<Lang>) -> Detector`

### Parameters
- **langs** (Vec<Lang>) - Required - A vector of `Lang` enums representing the languages to exclude.

### Returns
- **Detector** - A configured `Detector` instance.

### Example
```rust
use whatlang::{Detector, Lang};

let denylist = vec![Lang::Epo];
let detector = Detector::with_denylist(denylist);
```
```

--------------------------------

### Get ISO 639-3 code from Lang

Source: https://docs.rs/whatlang/latest/whatlang/enum.Lang.html

Converts a Lang enum value into its ISO 639-3 code string.

```rust
use whatlang::Lang;
assert_eq!(Lang::Ukr.code(), "ukr");
```

--------------------------------

### Get Lang from ISO 639-3 code

Source: https://docs.rs/whatlang/latest/whatlang/enum.Lang.html

Converts an ISO 639-3 code string into a Lang enum value. Returns Some(Lang) if the code is valid, otherwise None.

```rust
use whatlang::Lang;
assert_eq!(Lang::from_code("ukr"), Some(Lang::Ukr));
```

--------------------------------

### Specifying an allowlist with Detector::with_allowlist

Source: https://docs.rs/whatlang/latest/whatlang/struct.Detector.html

Creates a Detector with an allowlist of languages (English and Russian) and detects the language of an English phrase, expecting English.

```rust
use whatlang::{Detector, Lang};

// Create detector with allowlist
let detector = Detector::with_allowlist(vec![Lang::Eng, Lang::Rus]);
let lang = detector.detect_lang("That is not Russian");
assert_eq!(lang, Some(Lang::Eng));
```

--------------------------------

### Detect script with detect_script

Source: https://docs.rs/whatlang/latest/src/whatlang/scripts/detect.rs.html

Demonstrates how to use the `detect_script` function to identify the script of a provided string. It returns an `Option<Script>` which is `None` if no script can be determined.

```rust
use whatlang::{detect_script, Script};
let script = detect_script("Благодаря Эсперанто вы обрётете друзей по всему миру!").unwrap();
assert_eq!(script, Script::Cyrillic);
```

--------------------------------

### Options struct and implementation

Source: https://docs.rs/whatlang/latest/src/whatlang/core/options.rs.html

Defines the Options struct with filter_list and method fields, and provides methods for creating and configuring instances.

```rust
1use super::{FilterList, Method};

#[cfg_attr(feature = "arbitrary", derive(::arbitrary::Arbitrary))]
#[derive(Debug, Clone)]
pub struct Options {
    pub(crate) filter_list: FilterList,
    pub(crate) method: Method,
}

impl Options {
    pub fn new() -> Self {
        Self {
            filter_list: FilterList::All,
            method: Method::Combined,
        }
    }

    #[cfg(feature = "dev")]
    pub fn with_filter_list(filter_list: FilterList) -> Self {
        Self::new().set_filter_list(filter_list)
    }

    #[cfg(feature = "dev")]
    pub fn with_method(method: Method) -> Self {
        Self::new().set_method(method)
    }

    pub fn set_filter_list(mut self, filter_list: FilterList) -> Self {
        self.filter_list = filter_list;
        self
    }

    #[cfg(feature = "dev")]
    pub fn set_method(mut self, method: Method) -> Self {
        self.method = method;
        self
    }
}

impl Default for Options {
    fn default() -> Self {
        Self::new()
    }
}
```

--------------------------------

### Detect with FilterList Allow

Source: https://docs.rs/whatlang/latest/src/whatlang/core/detect.rs.html

Demonstrates using FilterList::allow to restrict detection to a specific set of languages.

```rust
#[test]
    fn test_detect_with_options_with_filter_list_only() {
        let filter_list = FilterList::allow(vec![Lang::Epo, Lang::Ukr]);
        let options = Options::new().set_filter_list(filter_list);

        let text = "Mi ne scias!";
        let output = detect_with_options(text, &options);
        assert_eq!(output.is_some(), true);
        let info = output.unwrap();
        assert_eq!(info.lang(), Lang::Epo);
    }
```

--------------------------------

### Test Display implementation for Script

Source: https://docs.rs/whatlang/latest/src/whatlang/scripts/script.rs.html

Verifies that the Display trait outputs the expected script names for Georgian, Cyrillic, and Arabic.

```rust
use super::*;

#[test]
fn test_script_display() {
    assert_eq!(Script::Georgian.to_string(), "Georgian");
    assert_eq!(Script::Cyrillic.to_string(), "Cyrillic");
    assert_eq!(Script::Arabic.to_string(), "Arabic");
}
```

--------------------------------

### Detector::detect(&self, text: &str) -> Option<Info>

Source: https://docs.rs/whatlang/latest/src/whatlang/core/detector.rs.html

Detects the language and script of the given text, returning an Info object if detection succeeds.

```APIDOC
## Detector::detect(&self, text: &str) -> Option<Info>

### Description
Detects the language and script of the given text, returning an Info object if detection succeeds.

### Method
Method

### Signature
```rust
pub fn detect(&self, text: &str) -> Option<Info>
```

### Parameters
- **text** (&str) - Required - The text to analyze.

### Returns
- **Option<Info>** - Some(Info) if detection succeeds, None otherwise. Info contains language and script.

### Example
```rust
let info = detector.detect("Ĉiuj redaktantoj...");
```
```

--------------------------------

### detect(text: &str) -> Option<Info>

Source: https://docs.rs/whatlang/latest/whatlang/fn.detect.html

Detects the language and script of the given text. Returns None if detection fails.

```APIDOC
## Function: detect

### Description
Detects a language and a script by a given text.

### Signature
pub fn detect(text: &str) -> Option<Info>

### Parameters
- **text** (&str) - Required - The input text to analyze.

### Return Value
- **Option<Info>** - Returns Some(Info) containing the detected language and script, or None if detection fails.

### Example
```rust
use whatlang::{detect_lang, Lang};
let lang = detect_lang("There is no reason not to learn Esperanto.").unwrap();
assert_eq!(lang, Lang::Eng);
```
```

--------------------------------

### Detect with Denylist for Ambiguous Characters

Source: https://docs.rs/whatlang/latest/src/whatlang/core/detect.rs.html

Shows how to use a denylist to exclude one language, forcing the detector to choose the other for shared characters.

```rust
#[test]
    fn test_detect_with_options_with_blacklist_mandarin_japanese() {
        let text = "水";

        let jpn_opts = Options::new().set_filter_list(FilterList::deny(vec![Lang::Jpn]));
        let info = detect_with_options(text, &jpn_opts).unwrap();
        assert_eq!(info.lang(), Lang::Cmn);

        let cmn_opts = Options::new().set_filter_list(FilterList::deny(vec![Lang::Cmn]));
        let info = detect_with_options(text, &cmn_opts).unwrap();
        assert_eq!(info.lang(), Lang::Jpn);
    }
```

--------------------------------

### Detecting Scripts for Various Languages

Source: https://docs.rs/whatlang/latest/src/whatlang/scripts/detect.rs.html

Demonstrates the use of detect_script to identify the script of strings in Latin, Cyrillic, Georgian, Mandarin, Arabic, Devanagari, Hebrew, and Ethiopic.

```rust
assert_eq!(detect_script("Hello!"), Some(Script::Latin));
        assert_eq!(detect_script("Привет всем!"), Some(Script::Cyrillic));
        assert_eq!(
            detect_script("ქართული ენა მსოფლიო "),
            Some(Script::Georgian)
        );
        assert_eq!(
            detect_script("県見夜上温国阪題富販"),
            Some(Script::Mandarin)
        );
        assert_eq!(
            detect_script(" ككل حوالي 1.6، ومعظم الناس "),
            Some(Script::Arabic)
        );
        assert_eq!(
            detect_script("हिमालयी वन चिड़िया (जूथेरा सालिमअली) चिड़िया की एक प्रजाति है"),
            Some(Script::Devanagari)
        );
        assert_eq!(
            detect_script("היסטוריה והתפתחות של האלפבית העברי"),
            Some(Script::Hebrew)
        );
        assert_eq!(
            detect_script("የኢትዮጵያ ፌዴራላዊ ዴሞክራሲያዊሪፐብሊክ"),
            Some(Script::Ethiopic)
        );
```

--------------------------------

### Detect with FilterList Deny

Source: https://docs.rs/whatlang/latest/src/whatlang/core/detect.rs.html

Demonstrates how to use FilterList::deny to exclude specific languages or scripts from detection, resulting in None if the text matches only denied languages.

```rust
#[test]
    fn test_detect_with_options_with_filter_list_except_none() {
        {
            // All languages with Hebrew script are filtered out, so result must be None
            let text = "האקדמיה ללשון העברית";
            let filter_list = FilterList::deny(vec![Lang::Heb, Lang::Yid]);
            let options = Options::new().set_filter_list(filter_list);
            let output = detect_with_options(text, &options);
            assert_eq!(output, None);
        }

        {
            // All Cyrillic languages are filtered out
            let text = "Мы хотим видеть дальше, чем окна дома напротив";
            let filter_list = FilterList::deny(Script::Cyrillic.langs().to_owned());
            let options = Options::new().set_filter_list(filter_list);
            let output = detect_with_options(text, &options);
            assert_eq!(output, None);
        }

        {
            // All Latin languages are filtered out
            let text = "Mit dem Wissen wächst der Zweifel";
            let filter_list = FilterList::deny(Script::Latin.langs().to_owned());
            let options = Options::new().set_filter_list(filter_list);
            let output = detect_with_options(text, &options);
            assert_eq!(output, None);
        }
    }
```

--------------------------------

### Detector::with_allowlist

Source: https://docs.rs/whatlang

Creates a Detector with an allowlist of languages to consider during detection. The detector can then be used to detect language from text.

```APIDOC
## Detector::with_allowlist

### Description
Creates a `Detector` with a specified allowlist of languages. The detector will only consider languages in the allowlist when detecting.

### Function Signature
`pub fn with_allowlist(langs: Vec<Lang>) -> Detector`

### Parameters
- **langs** (Vec<Lang>) - Required - A vector of `Lang` enums representing the allowed languages.

### Returns
- **Detector** - A configured `Detector` instance.

### Example
```rust
use whatlang::{Detector, Lang};

let allowlist = vec![Lang::Eng, Lang::Rus];
let detector = Detector::with_allowlist(allowlist);
let lang = detector.detect_lang("There is no reason not to learn Esperanto.");
assert_eq!(lang, Some(Lang::Eng));
```
```

--------------------------------

### Detect language using Detector with allowlist

Source: https://docs.rs/whatlang

Shows how to use the Detector struct with an allowlist to restrict detection to specific languages.

```rust
use whatlang::{Detector, Lang};

let allowlist = vec![Lang::Eng, Lang::Rus];

// You can also create detector using with_denylist function
let detector = Detector::with_allowlist(allowlist);
let lang = detector.detect_lang("There is no reason not to learn Esperanto.");
assert_eq!(lang, Some(Lang::Eng));
```

--------------------------------

### Iterate over all languages

Source: https://docs.rs/whatlang/latest/whatlang/enum.Lang.html

Iterates over all supported languages and prints each one using the Display implementation.

```rust
use whatlang::Lang;
for lang in Lang::all() {
    println!("{}", lang);
}
```

--------------------------------

### Script enum: all(), name(), langs(), Display, FromStr

Source: https://docs.rs/whatlang/latest/src/whatlang/scripts/script.rs.html

Defines the Script enum with 25 writing-system variants and a VALUES array. Script::all() returns the static slice of all variants, name() returns the canonical name, and langs() delegates to lang_mapping::script_langs. FromStr parses case-insensitive trimmed names and returns ParseError::Script for unknown input; Display writes the name().

```rust
use std::fmt;
use std::str::FromStr;

use super::lang_mapping;
use crate::Lang;
use crate::error::ParseError;

/// Represents a writing system (Latin, Cyrillic, Arabic, etc).
#[cfg_attr(feature = "enum-map", derive(::enum_map::Enum))]
#[cfg_attr(feature = "arbitrary", derive(::arbitrary::Arbitrary))]
#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))]
#[derive(PartialEq, Eq, Debug, Clone, Copy, Hash)]
pub enum Script {
    // Keep this in alphabetic order (for C bindings)
    Arabic,
    Armenian,
    Bengali,
    Cyrillic,
    Devanagari,
    Ethiopic,
    Georgian,
    Greek,
    Gujarati,
    Gurmukhi,
    Hangul,
    Hebrew,
    Hiragana,
    Kannada,
    Katakana,
    Khmer,
    Latin,
    Malayalam,
    Mandarin,
    Myanmar,
    Oriya,
    Sinhala,
    Tamil,
    Telugu,
    Thai,
}

// Array of all existing Script values.
const VALUES: [Script; 25] = [
    Script::Arabic,
    Script::Armenian,
    Script::Bengali,
    Script::Cyrillic,
    Script::Devanagari,
    Script::Ethiopic,
    Script::Georgian,
    Script::Greek,
    Script::Gujarati,
    Script::Gurmukhi,
    Script::Hangul,
    Script::Hebrew,
    Script::Hiragana,
    Script::Kannada,
    Script::Katakana,
    Script::Khmer,
    Script::Latin,
    Script::Malayalam,
    Script::Mandarin,
    Script::Myanmar,
    Script::Oriya,
    Script::Sinhala,
    Script::Tamil,
    Script::Telugu,
    Script::Thai,
];

impl Script {
    /// Get all existing scripts.
    ///
    /// # Example
    /// ```
    /// use whatlang::Script;
    /// for script in Script::all() {
    ///     println!("{}", script);
    /// }
    /// ```
    pub fn all() -> &'static [Script] {
        &VALUES
    }

    pub fn name(&self) -> &str {
        match *self {
            Script::Latin => "Latin",
            Script::Cyrillic => "Cyrillic",
            Script::Arabic => "Arabic",
            Script::Devanagari => "Devanagari",
            Script::Hiragana => "Hiragana",
            Script::Katakana => "Katakana",
            Script::Ethiopic => "Ethiopic",
            Script::Hebrew => "Hebrew",
            Script::Bengali => "Bengali",
            Script::Georgian => "Georgian",
            Script::Mandarin => "Mandarin",
            Script::Hangul => "Hangul",
            Script::Greek => "Greek",
            Script::Kannada => "Kannada",
            Script::Tamil => "Tamil",
            Script::Thai => "Thai",
            Script::Gujarati => "Gujarati",
            Script::Gurmukhi => "Gurmukhi",
            Script::Telugu => "Telugu",
            Script::Malayalam => "Malayalam",
            Script::Oriya => "Oriya",
            Script::Myanmar => "Myanmar",
            Script::Sinhala => "Sinhala",
            Script::Khmer => "Khmer",
            Script::Armenian => "Armenian",
        }
    }

    pub fn langs(&self) -> &[Lang] {
        lang_mapping::script_langs(*self)
    }
}

impl fmt::Display for Script {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name())
    }
}

impl FromStr for Script {
    type Err = ParseError;

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        match s.to_lowercase().trim() {
            "latin" => Ok(Script::Latin),
            "cyrillic" => Ok(Script::Cyrillic),
            "arabic" => Ok(Script::Arabic),
            "devanagari" => Ok(Script::Devanagari),
            "hiragana" => Ok(Script::Hiragana),
            "katakana" => Ok(Script::Katakana),
            "ethiopic" => Ok(Script::Ethiopic),
            "hebrew" => Ok(Script::Hebrew),
            "bengali" => Ok(Script::Bengali),
            "georgian" => Ok(Script::Georgian),
            "mandarin" => Ok(Script::Mandarin),
            "hangul" => Ok(Script::Hangul),
            "greek" => Ok(Script::Greek),
            "kannada" => Ok(Script::Kannada),
            "tamil" => Ok(Script::Tamil),
            "thai" => Ok(Script::Thai),
            "gujarati" => Ok(Script::Gujarati),
            "gurmukhi" => Ok(Script::Gurmukhi),
            "telugu" => Ok(Script::Telugu),
            "malayalam" => Ok(Script::Malayalam),
            "oriya" => Ok(Script::Oriya),
            "myanmar" => Ok(Script::Myanmar),
            "sinhala" => Ok(Script::Sinhala),
            "khmer" => Ok(Script::Khmer),
            "armenian" => Ok(Script::Armenian),
            _ => Err(ParseError::Script(s.to_string())),
        }
    }
}

#[cfg(test)]
mod tests {

```

--------------------------------

### Info::script

Source: https://docs.rs/whatlang/latest/whatlang/struct.Info.html

Returns the detected script.

```APIDOC
## Info::script

### Description
Returns the detected script.

### Method
`pub fn script(&self) -> Script`

### Parameters
- `self` - The `Info` instance.

### Returns
- `Script` - The detected script.
```

--------------------------------

### Detect with Allowlist for Ambiguous Characters

Source: https://docs.rs/whatlang/latest/src/whatlang/core/detect.rs.html

Shows how to use an allowlist to force detection of a specific language when characters are shared between multiple languages.

```rust
#[test]
    fn test_detect_with_options_with_allowlist_mandarin_japanese() {
        let text = "水";

        let jpn_opts = Options::new().set_filter_list(FilterList::allow(vec![Lang::Jpn]));
        let info = detect_with_options(text, &jpn_opts).unwrap();
        assert_eq!(info.lang(), Lang::Jpn);

        let cmn_opts = Options::new().set_filter_list(FilterList::allow(vec![Lang::Cmn]));
        let info = detect_with_options(text, &cmn_opts).unwrap();
        assert_eq!(info.lang(), Lang::Cmn);
    }
```

--------------------------------

### detection.rs: detect and raw_detect functions

Source: https://docs.rs/whatlang/latest/src/whatlang/alphabets/detection.rs.html

The detect function computes confidence and returns language info. raw_detect dispatches to alphabet-specific scoring or mock builders for unimplemented scripts.

```rust
use super::RawOutcome;
use super::{cyrillic, latin};
use crate::Lang;
use crate::core::{FilterList, Info, InternalQuery, LowercaseText, calculate_confidence};

pub fn detect(iquery: &InternalQuery) -> Option<Info> {
    let raw_outcome = raw_detect(iquery);
    let RawOutcome { count, scores, .. } = raw_outcome;

    let mut normalized_scores_iter = scores.into_iter();
    let opt_lang_score1 = normalized_scores_iter.next();
    let opt_lang_score2 = normalized_scores_iter.next();

    opt_lang_score1.map(|(lang1, score1)| {
        let script = iquery.multi_lang_script.to_script();
        let confidence = if let Some((_, score2)) = opt_lang_score2 {
            calculate_confidence(score1, score2, count)
        } else {
            1.0
        };
        Info::new(script, lang1, confidence)
    })
}

pub fn raw_detect(iquery: &InternalQuery) -> RawOutcome {
    use crate::scripts::grouping::MultiLangScript as MLS;

    let text: &LowercaseText = &iquery.text.lowercase();
    let filter_list: &FilterList = iquery.filter_list;
    match iquery.multi_lang_script {
        MLS::Cyrillic => cyrillic::alphabet_calculate_scores(text, filter_list),
        MLS::Latin => latin::alphabet_calculate_scores(text, filter_list),

        // TODO: implement alphabets for Arabic script
        MLS::Arabic => build_mock(vec![Lang::Ara, Lang::Urd, Lang::Pes], filter_list),

        // TODO: implement alphabets for Devanagari script
        MLS::Devanagari => build_mock(vec![Lang::Hin, Lang::Mar, Lang::Nep], filter_list),

        // TODO: implement alphabets for Hebrew script
        MLS::Hebrew => build_mock(vec![Lang::Heb, Lang::Yid], filter_list),
    }
}

fn build_mock(langs: Vec<Lang>, filter_list: &FilterList) -> RawOutcome {
    let filtered_langs = langs
        .into_iter()
        .filter(|lang| filter_list.is_allowed(*lang));
    let raw_scores = filtered_langs.clone().map(|l| (l, 1)).collect();
    let scores = filtered_langs.map(|l| (l, 1.0)).collect();
    RawOutcome {
        count: 1,
        raw_scores,
        scores,
    }
}

```

--------------------------------

### Detector::detect_script(&self, text: &str) -> Option<Script>

Source: https://docs.rs/whatlang/latest/src/whatlang/core/detector.rs.html

Detects the script of the given text, returning the detected script if successful.

```APIDOC
## Detector::detect_script(&self, text: &str) -> Option<Script>

### Description
Detects the script of the given text, returning the detected script if successful.

### Method
Method

### Signature
```rust
pub fn detect_script(&self, text: &str) -> Option<Script>
```

### Parameters
- **text** (&str) - Required - The text to analyze.

### Returns
- **Option<Script>** - Some(Script) if detection succeeds, None otherwise.

### Example
```rust
let script = detector.detect_script("Кириллица");
```
```

--------------------------------

### Combined Language Detection Implementation

Source: https://docs.rs/whatlang/latest/src/whatlang/combined/mod.rs.html

The core implementation for combining detection results from alphabets and trigrams, including the RawOutcome structure and the detect function.

```rust
use crate::Lang;
use crate::alphabets;
use crate::core::{Info, InternalQuery, calculate_confidence};
use crate::trigrams;

#[derive(Debug)]
pub struct RawOutcome {
    pub scores: Vec<(Lang, f64)>,
    #[allow(dead_code)]
    pub alphabet_raw_outcome: alphabets::RawOutcome,
    pub trigram_raw_outcome: trigrams::RawOutcome,
}

pub fn detect(iquery: &InternalQuery) -> Option<Info> {
    let raw_outcome = raw_detect(iquery);

    let count = raw_outcome.trigram_raw_outcome.trigrams_count;
    let mut normalized_scores_iter = raw_outcome.scores.into_iter();

    let opt_lang_score1 = normalized_scores_iter.next();
    let opt_lang_score2 = normalized_scores_iter.next();

    // TODO: Logic is duplicated in alphabets and trigrams. Consider refactoring
    opt_lang_score1.map(|(lang1, score1)| {
        let script = iquery.multi_lang_script.to_script();
        let confidence = if let Some((_, score2)) = opt_lang_score2 {
            calculate_confidence(score1, score2, count)
        } else {
            1.0
        };
        Info::new(script, lang1, confidence)
    })
}

// TODO: optimize!
pub fn raw_detect(iquery: &InternalQuery) -> RawOutcome {
    let alphabet_raw_outcome: alphabets::RawOutcome = alphabets::raw_detect(iquery);
    let trigram_raw_outcome: trigrams::RawOutcome = trigrams::raw_detect(iquery);

    let alphabet_scores: &Vec<(Lang, f64)> = &alphabet_raw_outcome.scores;
    let trigram_scores: &Vec<(Lang, f64)> = &trigram_raw_outcome.scores;

    let mut all_langs: Vec<Lang> = alphabet_scores.iter().map(|x| x.0).collect();
    for (lang, _) in trigram_scores.iter() {
        if !all_langs.contains(lang) {
            all_langs.push(*lang);
        }
    }

    let count = alphabet_raw_outcome.count;

    let alphabet_weight = calc_alphabet_weight(count);
    let trigram_weight = 1.0 - alphabet_weight;

    let mut scores = Vec::with_capacity(all_langs.len());

    for lang in all_langs {
        let a: f64 = alphabet_scores
            .iter()
            .find(|(l, _)| l == &lang)
            .map(|x| x.1)
            .unwrap_or(0.0);
        let t: f64 = trigram_scores
            .iter()
            .find(|(l, _)| l == &lang)
            .map(|x| x.1)
            .unwrap_or(0.0);

        debug_assert!(a >= 0.0);
        debug_assert!(a <= 1.0);
        debug_assert!(t >= 0.0);
        debug_assert!(t <= 1.0);

        let score = a * alphabet_weight + t * trigram_weight;

        debug_assert!(score >= 0.0);
        debug_assert!(score <= 1.0);

        scores.push((lang, score));
    }

    scores.sort_unstable_by(|a, b| b.1.partial_cmp(&a.1).unwrap_or(std::cmp::Ordering::Less));

    RawOutcome {
        scores,
        alphabet_raw_outcome,
        trigram_raw_outcome,
    }
}
```

--------------------------------

### detect_with_options

Source: https://docs.rs/whatlang/latest/src/whatlang/core/detect.rs.html

Detects the language and script of a given text using custom options, such as a filter list and detection method. This allows for more control over the detection process.

```APIDOC
## detect_with_options

### Description
Detects the language and script of a given text using custom options, such as a filter list and detection method. This allows for more control over the detection process.

### Function Signature
`pub fn detect_with_options(text: &str, options: &Options) -> Option<Info>`

### Parameters
- **text** (&str) - Required - The input text to detect the language and script for.
- **options** (&Options) - Required - Configuration options for detection, including filter_list and method.

### Returns
- **Option<Info>** - An Info object containing the detected language and script, or None if detection fails.

### Example
```rust
use whatlang::{detect_with_options, Options, FilterList, Lang};
let filter_list = FilterList::deny(vec![Lang::Jav, Lang::Nld]);
let options = Options::new().filter_list(filter_list);
let info = detect_with_options("I am begging pardon", &options).unwrap();
```
```

--------------------------------

### Define MultiLangScript and ScriptLangGroup

Source: https://docs.rs/whatlang/latest/src/whatlang/scripts/grouping.rs.html

Defines the structures for grouping scripts and mapping them to languages.

```rust
1use super::Script;
2use crate::Lang;
3
4#[derive(Debug, Clone, Copy, PartialEq, Eq)]
5pub enum MultiLangScript {
6    Latin,
7    Cyrillic,
8    Arabic,
9    Devanagari,
10    Hebrew,
11}
12
13impl MultiLangScript {
14    pub fn to_script(self) -> Script {
15        match self {
16            Self::Latin => Script::Latin,
17            Self::Cyrillic => Script::Cyrillic,
18            Self::Arabic => Script::Arabic,
19            Self::Devanagari => Script::Devanagari,
20            Self::Hebrew => Script::Hebrew,
21        }
22    }
23}
24
25#[derive(Debug, Clone, Copy, PartialEq, Eq)]
26pub enum ScriptLangGroup {
27    Multi(MultiLangScript),
28    One(Lang),
29
30    // Mandarin writing can be japanese in some cases.
31    // For now it's a hack.
32    // See https://github.com/greyblake/whatlang-rs/pull/45
33    Mandarin,
34}
35
36impl Script {
37    pub fn to_lang_group(self) -> ScriptLangGroup {
38        use MultiLangScript as MLS;
39        use ScriptLangGroup::{Mandarin, Multi, One};
40
41        match self {
42            Script::Latin => Multi(MLS::Latin),
43            Script::Cyrillic => Multi(MLS::Cyrillic),
44            Script::Arabic => Multi(MLS::Arabic),
45            Script::Devanagari => Multi(MLS::Devanagari),
46            Script::Hebrew => Multi(MLS::Hebrew),
47            Script::Mandarin => Mandarin,
48            Script::Bengali => One(Lang::Ben),
49            Script::Hangul => One(Lang::Kor),
50            Script::Georgian => One(Lang::Kat),
51            Script::Greek => One(Lang::Ell),
52            Script::Kannada => One(Lang::Kan),
53            Script::Tamil => One(Lang::Tam),
54            Script::Thai => One(Lang::Tha),
55            Script::Gujarati => One(Lang::Guj),
56            Script::Gurmukhi => One(Lang::Pan),
57            Script::Telugu => One(Lang::Tel),
58            Script::Malayalam => One(Lang::Mal),
59            Script::Oriya => One(Lang::Ori),
60            Script::Myanmar => One(Lang::Mya),
61            Script::Sinhala => One(Lang::Sin),
62            Script::Khmer => One(Lang::Khm),
63            Script::Ethiopic => One(Lang::Amh),
64            Script::Armenian => One(Lang::Hye),
65            Script::Katakana | Script::Hiragana => One(Lang::Jpn),
66        }
67    }
68}
```

--------------------------------

### FromStr for Script

Source: https://docs.rs/whatlang/latest/src/whatlang/scripts/script.rs.html

Parses a string into a `Script` value.

```APIDOC
## FromStr for Script

### Description
Parses a string into a `Script` value. The input is case-insensitive and trimmed.

### Method
`fn from_str(s: &str) -> Result<Self, Self::Err>`

### Parameters
- `s` (`&str`) - The string to parse, e.g., "latin", "Cyrillic".

### Returns
- `Result<Script, ParseError>` - `Ok(Script)` if the string matches a known script name, otherwise `Err(ParseError::Script)`.

### Example
```rust
use std::str::FromStr;
use whatlang::Script;
let script = Script::from_str("latin").unwrap();
```
```

--------------------------------

### Info struct methods

Source: https://docs.rs/whatlang

The Info struct represents the full outcome of language detection and provides methods to access the detected language, script, confidence, and reliability.

```APIDOC
## Info struct

### Description
Represents a full outcome of language detection.

### Methods

#### lang()
- **Signature**: `pub fn lang(&self) -> Lang`
- **Description**: Returns the detected language.

#### script()
- **Signature**: `pub fn script(&self) -> Script`
- **Description**: Returns the detected script.

#### confidence()
- **Signature**: `pub fn confidence(&self) -> f64`
- **Description**: Returns the confidence score in the range from 0 to 1.

#### is_reliable()
- **Signature**: `pub fn is_reliable(&self) -> bool`
- **Description**: Returns whether the detection is considered reliable.

### Example
```rust
use whatlang::{detect, Lang, Script};

let text = "Ĉu vi ne volas eklerni Esperanton? Bonvolu! Estas unu de la plej bonaj aferoj!";
let info = detect(text).unwrap();
assert_eq!(info.lang(), Lang::Epo);
assert_eq!(info.script(), Script::Latin);
assert_eq!(info.confidence(), 1.0);
assert!(info.is_reliable());
```
```

--------------------------------

### detect_by_query function

Source: https://docs.rs/whatlang/latest/src/whatlang/core/detect.rs.html

Public function that detects language based on a Query, using raw script detection and handling script language groups.

```rust
pub fn detect_by_query(query: &Query) -> Option<Info> {
    let raw_script_info = raw_detect_script(query.text);
    let script = raw_script_info.main_script()?;

    match script.to_lang_group() {
        ScriptLangGroup::One(lang) => Some(Info::new(script, lang, 1.0)),
        ScriptLangGroup::Multi(multi_lang_script) => {
            detect_by_query_based_on_script(query, multi_lang_script)
        }
        ScriptLangGroup::Mandarin => {
            Some(detect_lang_base_on_mandarin_script(query, &raw_script_info))
        }
    }
}
```

--------------------------------

### Detecting Scripts in Mixed-Script Text

Source: https://docs.rs/whatlang/latest/src/whatlang/scripts/detect.rs.html

Shows how detect_script handles strings containing multiple scripts by returning the primary script detected.

```rust
// Mixed scripts
        assert_eq!(
            detect_script("Привет! Текст на русском with some English."),
            Some(Script::Cyrillic)
        );
        assert_eq!(
            detect_script("Russian word любовь means love."),
            Some(Script::Latin)
        );
    }
}
```