//! Unicode script detection and language identification for text shaping

//!

// Taken from: https://github.com/greyblake/whatlang-rs/blob/master/src/scripts/detect.rs

//

// See: https://github.com/greyblake/whatlang-rs/pull/67

// License:

//

// (The MIT License)

//

// Copyright (c) 2017 Sergey Potapov <blake131313@gmail.com>

// Copyright (c) 2014 Titus Wormer <tituswormer@gmail.com>

// Copyright (c) 2008 Kent S Johnson

// Copyright (c) 2006 Jacob R Rideout <kde@jacobrideout.net>

// Copyright (c) 2004 Maciej Ceglowski

//

// Permission is hereby granted, free of charge, to any person obtaining

// a copy of this software and associated documentation files (the

// 'Software'), to deal in the Software without restriction, including

// without limitation the rights to use, copy, modify, merge, publish,

// distribute, sublicense, and/or sell copies of the Software, and to

// permit persons to whom the Software is furnished to do so, subject to

// the following conditions:

//

// The above copyright notice and this permission notice shall be

// included in all copies or substantial portions of the Software.

//

// THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,

// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.

// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY

// CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,

// TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE

// SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

#[cfg(feature = "text_layout_hyphenation")]

use hyphenation::Language as HyphenationLanguage;

#[cfg(feature = "text_layout_hyphenation")]

pub use hyphenation::Language;

/// Stub Language enum for when hyphenation is not enabled.

/// This mirrors the variants used in script detection functions.

#[cfg(not(feature = "text_layout_hyphenation"))]

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]

#[allow(dead_code)]

pub enum Language {

    // Latin script languages

    EnglishUS,

    French,

    German1996,

    Spanish,

    Portuguese,

    Estonian,

    Hungarian,

    Polish,

    Czech,

    Slovak,

    Latvian,

    Lithuanian,

    Romanian,

    Turkish,

    Croatian,

    Icelandic,

    Welsh,

    NorwegianBokmal,

    Swedish,

    // Cyrillic script languages

    Russian,

    Ukrainian,

    Belarusian,

    Bulgarian,

    Macedonian,

    SerbianCyrillic,

    Mongolian,

    SlavonicChurch,

    // Greek script languages

    GreekMono,

    GreekPoly,

    Coptic,

    // Indic script languages

    Hindi,

    Bengali,

    Assamese,

    Marathi,

    Sanskrit,

    Gujarati,

    Panjabi,

    Kannada,

    Malayalam,

    Oriya,

    Tamil,

    Telugu,

    // Other scripts

    Georgian,

    Ethiopic,

    Thai,

    Chinese,

}

#[derive(PartialEq, Eq, Debug, Clone, Copy)]

pub enum Script {

    // Keep this in alphabetic order (for C bindings)

    Arabic,

    Bengali,

    Cyrillic,

    Devanagari,

    Ethiopic,

    Georgian,

    Greek,

    Gujarati,

    Gurmukhi,

    Hangul,

    Hebrew,

    Hiragana,

    Kannada,

    Katakana,

    Khmer,

    Latin,

    Malayalam,

    Mandarin,

    Myanmar,

    Oriya,

    Sinhala,

    Tamil,

    Telugu,

    Thai,

}

// Is it space, punctuation or digit?

// Stop character is a character that does not give any value for script

// or language detection.

#[inline]

type ScriptChecker = (Script, fn(char) -> bool);

type ScriptCounter = (Script, fn(char) -> bool, usize);

const SCRIPT_CHECKERS: [ScriptChecker; 24] = [

    (Script::Latin, is_latin),

    (Script::Cyrillic, is_cyrillic),

    (Script::Arabic, is_arabic),

    (Script::Mandarin, is_mandarin),

    (Script::Devanagari, is_devanagari),

    (Script::Hebrew, is_hebrew),

    (Script::Ethiopic, is_ethiopic),

    (Script::Georgian, is_georgian),

    (Script::Bengali, is_bengali),

    (Script::Hangul, is_hangul),

    (Script::Hiragana, is_hiragana),

    (Script::Katakana, is_katakana),

    (Script::Greek, is_greek),

    (Script::Kannada, is_kannada),

    (Script::Tamil, is_tamil),

    (Script::Thai, is_thai),

    (Script::Gujarati, is_gujarati),

    (Script::Gurmukhi, is_gurmukhi),

    (Script::Telugu, is_telugu),

    (Script::Malayalam, is_malayalam),

    (Script::Oriya, is_oriya),

    (Script::Myanmar, is_myanmar),

    (Script::Sinhala, is_sinhala),

    (Script::Khmer, is_khmer),

];

/// Detect only a script by a given text

/// # Panics

///

/// Panics only if the internal script-counter table were empty, which cannot happen (it is a fixed-size array).

        // For performance reasons, we need to mutate script_counters by calling

        // `swap` function, it would not be possible to do using normal iterator.

                } else {

                }

            };

            // Have to let borrow of count fall out of scope before doing swapping, or we could

            // do this above.

                // If script was found, move it closer to the front.

                // If the text contains largely 1 or 2 scripts, this will

                // cause these scripts to be eventually checked first.

        }

    }

    } else {

    }

    }

/// Iterates through the text once and returns as soon as an Assamese-specific character is found.

        // These characters are specific to Assamese in the Bengali script block.

        // We can return immediately as this is the highest priority check.

            // ৰ, ৱ

    }

    // If we finish the loop without finding any Assamese characters, it's Bengali.

            // Highest priority: Old Cyrillic characters for Slavonic Church. Return immediately.

            // Set flags for other languages. We don't return yet because a higher-priority

            // character (like the one above) could still appear.

            // Bulgarian 'ъ' is also in Russian, but 'щ' is a stronger indicator.

            // The logic implies that if either is present, it might be Bulgarian.

        }

    }

            // Marathi has higher priority in the original logic. Return immediately.

            // Flag for Sanskrit Vedic extensions.

        }

    }

            // Coptic has higher priority. Return immediately.

            // Flag for Greek Extended (Polytonic) characters.

        }

    }

#[allow(clippy::match_same_arms)] // enum/value mapping/dispatch table: one arm per input variant (or cross-type bindings that can't merge)

    // Flags for languages checked near the end of the original if-else chain.

            // --- Early Return Cases (in order of priority) ---

            'ā' | 'ē' | 'ģ' | 'ī' | 'ķ' | 'ļ' | 'ņ' | 'ō' | 'ū' => {

            }

            // original's intent

            // NOTE: 'õ' is used by both Estonian and Portuguese

            // Since Estonian is checked first, it takes precedence.

            // --- Flag-setting Cases ---

        }

    }

    // decide between portuguese, estonian and french

#[allow(clippy::match_same_arms)] // enum/value mapping/dispatch table: one arm per input variant (or cross-type bindings that can't merge)

        // not directly matchable

        // no classical hyphenation behaviour

    }

        | '\u{1D2B}'

        | '\u{1D78}'

        | '\u{A69F}'

    )

// https://en.wikipedia.org/wiki/Latin_script_in_Unicode

    )

// Based on https://en.wikipedia.org/wiki/Arabic_script_in_Unicode

    )

// Based on https://en.wikipedia.org/wiki/Devanagari#Unicode

// Based on https://www.key-shortcut.com/en/writing-systems/ethiopian-script/

// Based on https://en.wikipedia.org/wiki/Hebrew_(Unicode_block)

        | '\u{3005}'

        | '\u{3007}'

    )

        // Halfwidth Katakana (part of the Halfwidth and Fullwidth Forms block).

        // U+FF66..=FF9F are katakana; U+FF61..=FF65 are halfwidth CJK punctuation.

    )

// Hangul is Korean Alphabet. Unicode ranges are taken from: https://en.wikipedia.org/wiki/Hangul

        // Halfwidth Hangul variants only. The rest of the Halfwidth and Fullwidth

        // Forms block (U+FF00..=FF60 fullwidth ASCII/Latin, U+FF61..=FF9F halfwidth

        // katakana/punct, U+FFE0..=FFEF fullwidth/halfwidth symbols) and Enclosed CJK

        // Letters and Months (U+3200..=32FF) are NOT Hangul and were previously

        // swallowed here, misclassifying halfwidth kana and fullwidth Latin as Hangul.

    )

// Taken from: https://en.wikipedia.org/wiki/Greek_and_Coptic

// Based on: https://en.wikipedia.org/wiki/Kannada_(Unicode_block)

// Based on: https://en.wikipedia.org/wiki/Tamil_(Unicode_block)

// Based on: https://en.wikipedia.org/wiki/Thai_(Unicode_block)

// Based on: https://en.wikipedia.org/wiki/Gujarati_(Unicode_block)

// Gurmukhi is the script for Punjabi language.

// Based on: https://en.wikipedia.org/wiki/Gurmukhi_(Unicode_block)

// Based on: https://en.wikipedia.org/wiki/Malayalam_(Unicode_block)

// Based on: https://en.wikipedia.org/wiki/Oriya_(Unicode_block)

// Based on: https://en.wikipedia.org/wiki/Myanmar_(Unicode_block)

// Based on: https://en.wikipedia.org/wiki/Sinhala_(Unicode_block)

// Based on: https://en.wikipedia.org/wiki/Khmer_alphabet

#[cfg(test)]

mod script_class_tests {

    use super::{detect_script, is_hangul, is_katakana, Script};

    #[test]

        // U+FF71..FF73 = halfwidth katakana ｱｲｳ — must classify as Katakana, not Hangul.

        }

    #[test]

        // U+FF21..FF23 = fullwidth ＡＢＣ — must not be classified as Hangul.

        }

    #[test]

}

#[cfg(test)]

#[allow(clippy::unicode_not_nfc, clippy::non_ascii_literal)]

mod autotest_generated {

    use super::*;

    // ---------------------------------------------------------------------

    // Helpers

    // ---------------------------------------------------------------------

    /// Every `Script` variant, in declaration order.

    const ALL_SCRIPTS: [Script; 24] = [

        Script::Arabic,

        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,

    ];

    /// `Script` has no `Hash`/`Ord`, so index it by hand for set-like bookkeeping.

    fn script_index(s: Script) -> usize {

        ALL_SCRIPTS

            .iter()

            .position(|&x| x == s)

            .expect("ALL_SCRIPTS must list every Script variant")

    }

    /// The first checker in `SCRIPT_CHECKERS` that claims `ch` — i.e. exactly what

    /// both `detect_char_script` and (for a 1-char text) `detect_script` must return.

    fn first_checker_hit(ch: char) -> Option<Script> {

        SCRIPT_CHECKERS

            .iter()

            .find(|(_, check_fn)| check_fn(ch))

            .map(|&(script, _)| script)

    }

    /// Iterate every scalar value in the BMP (surrogates are not `char`s).

    fn bmp_chars() -> impl Iterator<Item = char> {

        (0u32..=0xFFFF).filter_map(char::from_u32)

    }

    /// Deterministic pseudo-random scalar values — no `rand` dependency, and the

    /// sequence is identical on every run so a failure is always reproducible.

    fn lcg_chars(count: usize, seed: u64) -> String {

        let mut state = seed;

        let mut out = String::with_capacity(count * 4);

        let mut pushed = 0usize;

        while pushed < count {

            state = state

                .wrapping_mul(6_364_136_223_846_793_005)

                .wrapping_add(1_442_695_040_888_963_407);

            let cp = (state >> 16) as u32 % 0x0011_0000;

            if let Some(ch) = char::from_u32(cp) {

                out.push(ch);

                pushed += 1;

            }

        }

        out

    }

    // ---------------------------------------------------------------------

    // is_stop_char (predicate)

    // ---------------------------------------------------------------------

    // Const-evaluability is part of the API: these must fold at compile time.

    const _: bool = is_stop_char(' ');

    const _: bool = is_latin('a');

    const _: bool = is_khmer('\u{1780}');

    #[test]

    fn is_stop_char_basic_true_false() {

        for ch in [

            '\u{0000}', '\t', '\n', '\r', ' ', '!', '0', '9', '@', '[', '\\', ']', '^', '_', '`',

            '{', '|', '}', '~',

        ] {

            assert!(is_stop_char(ch), "{ch:?} should be a stop char");

        }

        for ch in ['a', 'z', 'A', 'Z', '\u{007F}', 'é', 'あ', 'م', '\u{10FFFF}'] {

            assert!(!is_stop_char(ch), "{ch:?} should not be a stop char");

        }

    }

    #[test]

    fn is_stop_char_range_boundaries_are_exact() {

        // '\u{0000}'..='\u{0040}'

        assert!(is_stop_char('\u{0040}'));

        assert!(!is_stop_char('\u{0041}')); // 'A' — first char past the first range

        // '\u{005B}'..='\u{0060}'

        assert!(!is_stop_char('\u{005A}')); // 'Z'

        assert!(is_stop_char('\u{005B}'));

        assert!(is_stop_char('\u{0060}'));

        assert!(!is_stop_char('\u{0061}')); // 'a'

        // '\u{007B}'..='\u{007E}'

        assert!(!is_stop_char('\u{007A}')); // 'z'

        assert!(is_stop_char('\u{007B}'));

        assert!(is_stop_char('\u{007E}'));

        // U+007F (DEL) is deliberately *outside* every stop range and every script

        // range: it is counted toward `half` in detect_script but never scores.

        assert!(!is_stop_char('\u{007F}'));

        assert_eq!(detect_char_script('\u{007F}'), None);

        assert!(!is_stop_char('\u{0080}'));

    }

    #[test]

    fn stop_chars_never_carry_a_script() {

        // Invariant the whole detector rests on: a stop char scores for nothing,

        // so a stop-only text can never produce a Some(script).

        for ch in bmp_chars() {

            if is_stop_char(ch) {

                assert_eq!(

                    detect_char_script(ch),

                    None,

                    "stop char {ch:?} (U+{:04X}) also matched a script checker",

                    ch as u32

                );

            }

        }

    }

    // ---------------------------------------------------------------------

    // detect_script (parser)

    // ---------------------------------------------------------------------

    #[test]

    fn detect_script_empty_input_returns_none() {

        assert_eq!(detect_script(""), None);

    }

    #[test]

    fn detect_script_whitespace_only_returns_none() {

        for text in ["   ", "\t\n", "\r\n\r\n", "\t \t \n", "\u{0000}\u{0000}"] {

            assert_eq!(detect_script(text), None, "whitespace {text:?}");

        }

    }

    #[test]

    fn detect_script_non_ascii_whitespace_scores_nothing() {

        // U+2003 EM SPACE / U+2028 LINE SEPARATOR are *not* stop chars (they are

        // above U+007E) but no checker claims them either — so still None.

        assert_eq!(detect_script("\u{2003}\u{2003}"), None);

        assert_eq!(detect_script("\u{2028}"), None);

    }

    #[test]

    fn detect_script_garbage_returns_none_without_panicking() {

        for text in [

            "\u{0001}\u{0002}\u{0003}",

            "\u{007F}\u{007F}\u{007F}",

            "!@#$%^&*()_+-=[]{}|;':\",./<>?",

            "\u{FFFD}\u{FFFD}",

            "\u{200B}\u{200C}\u{200D}", // zero-width space / non-joiner / joiner

        ] {

            assert_eq!(detect_script(text), None, "garbage {text:?}");

        }

    }

    #[test]

    fn detect_script_boundary_number_strings() {

        // Digits, signs and dots are all stop chars → nothing to score.

        for text in [

            "0",

            "-0",

            "9223372036854775807",  // i64::MAX

            "-9223372036854775808", // i64::MIN

            "18446744073709551615", // u64::MAX

            "1e309",                // f64 overflow literal — 'e' is Latin though

            "0.0000000000000000001",

        ] {

            let got = detect_script(text);

            let expected = if text.chars().any(|c| c.is_ascii_alphabetic()) {

                Some(Script::Latin)

            } else {

                None

            };

            assert_eq!(got, expected, "numeric text {text:?}");

        }

        // "NaN" / "inf" are pure ASCII letters → Latin, not a crash.

        assert_eq!(detect_script("NaN"), Some(Script::Latin));

        assert_eq!(detect_script("inf"), Some(Script::Latin));

        assert_eq!(detect_script("-inf"), Some(Script::Latin));

    }

    #[test]

    fn detect_script_leading_trailing_junk_is_skipped() {

        assert_eq!(detect_script("  hello  "), Some(Script::Latin));

        assert_eq!(detect_script("valid;garbage"), Some(Script::Latin));

        assert_eq!(detect_script("\t\nПривет\t\n"), Some(Script::Cyrillic));

    }

    #[test]

    fn detect_script_minority_script_still_wins_over_stop_chars() {

        // "a!!!!!!!!" is 9 chars → half == 4, so the single Latin char never crosses

        // the early-exit threshold. It must still win via the max-count fallback

        // (count != 0), not fall through to None.

        assert_eq!(detect_script("a!!!!!!!!"), Some(Script::Latin));

        assert_eq!(detect_script("!!!!!!!!!"), None);

    }

    #[test]

    fn detect_script_unicode_input_does_not_panic() {

        for text in [

            "\u{1F600}",                           // emoji, matches no script

            "\u{1F600}\u{1F468}\u{200D}\u{1F469}", // ZWJ sequence

            "e\u{0301}",                           // 'e' + combining acute

            "\u{0301}\u{0302}\u{0303}",            // bare combining marks

            "\u{10FFFF}",                          // char::MAX

            "\u{FFFF}",                            // BMP noncharacter

        ] {

            let got = detect_script(text);

            assert_eq!(got, detect_script(text), "not deterministic for {text:?}");

        }

        assert_eq!(detect_script("\u{1F600}"), None);

        assert_eq!(detect_script("\u{0301}\u{0302}"), None);

        assert_eq!(detect_script("\u{10FFFF}"), None);

        assert_eq!(detect_script("e\u{0301}"), Some(Script::Latin));

    }

    #[test]

    fn detect_script_deeply_nested_brackets_do_not_stack_overflow() {

        // 10_000 nested brackets: the detector is iterative, and every bracket is a

        // stop char, so this must terminate with None rather than recursing.

        let depth = 10_000;

        let mut text = String::with_capacity(depth * 2);

        for _ in 0..depth {

            text.push('(');

        }

        for _ in 0..depth {

            text.push(')');

        }

        assert_eq!(detect_script(&text), None);

        let mut nested = String::new();

        for _ in 0..depth {

            nested.push_str("{[");

        }

        for _ in 0..depth {

            nested.push_str("]}");

        }

        assert_eq!(detect_script(&nested), None);

    }

    #[test]

    fn detect_script_extremely_long_input_terminates() {

        // 1M identical Latin chars: must early-exit once count > half.

        let long_latin = "a".repeat(1_000_000);

        assert_eq!(detect_script(&long_latin), Some(Script::Latin));

        // 200k chars that match *no* checker: worst case — all 24 checkers run for

        // every char and there is no early exit. Must still finish, returning None.

        let long_junk = "\u{1F600}".repeat(200_000);

        assert_eq!(detect_script(&long_junk), None);

        // 200k stop chars: skipped, but still walked.

        let long_stops = " ".repeat(200_000);

        assert_eq!(detect_script(&long_stops), None);

    }

    #[test]

    fn detect_script_long_mixed_script_input_is_deterministic() {

        // Alternating scripts defeat the "move winner to the front" heuristic and

        // never cross the half threshold. It must still terminate and be stable.

        let mixed = "aб".repeat(100_000);

        let first = detect_script(&mixed);

        let second = detect_script(&mixed);

        assert_eq!(first, second, "detect_script is not deterministic");

        assert!(

            first == Some(Script::Latin) || first == Some(Script::Cyrillic),

            "expected one of the two present scripts, got {first:?}"

        );

    }

    #[test]

    fn detect_script_pseudo_random_garbage_never_panics() {

        for seed in [1u64, 0xDEAD_BEEF, u64::MAX] {

            let text = lcg_chars(5_000, seed);

            let first = detect_script(&text);

            let second = detect_script(&text);

            assert_eq!(first, second, "non-deterministic for seed {seed}");

        }

    }

    #[test]

    fn detect_script_majority_wins() {

        assert_eq!(detect_script("aaaaaб"), Some(Script::Latin));

        assert_eq!(detect_script("бббббa"), Some(Script::Cyrillic));

        // Latin body with a couple of CJK chars mixed in.

        assert_eq!(detect_script("hello 世界"), Some(Script::Latin));

        assert_eq!(detect_script("世界世界 hi"), Some(Script::Mandarin));

    }

    #[test]

    fn detect_script_valid_minimal_positive_controls() {

        let cases: [(&str, Script); 16] = [

            ("hello", Script::Latin),

            ("Привет", Script::Cyrillic),

            ("مرحبا", Script::Arabic),

            ("你好世界", Script::Mandarin),

            ("नमस्ते", Script::Devanagari),

            ("שלום", Script::Hebrew),

            ("ሰላም", Script::Ethiopic),

            ("გამარჯობა", Script::Georgian),

            ("আমার", Script::Bengali),

            ("안녕하세요", Script::Hangul),

            ("こんにちは", Script::Hiragana),

            ("カタカナ", Script::Katakana),

            ("Γειά", Script::Greek),

            ("ಕನ್ನಡ", Script::Kannada),

            ("தமிழ்", Script::Tamil),

            ("สวัสดี", Script::Thai),

        ];

        for (text, expected) in cases {

            assert_eq!(detect_script(text), Some(expected), "text {text:?}");

        }

    }

    #[test]

    fn detect_script_is_pure_no_state_leaks_between_calls() {

        // detect_script mutates (swaps) its counter table; that table must be local.

        // Priming it with Cyrillic must not change the verdict for a later Latin text.

        assert_eq!(detect_script("ббббб"), Some(Script::Cyrillic));

        assert_eq!(detect_script("aaaaa"), Some(Script::Latin));

        assert_eq!(detect_script("ббббб"), Some(Script::Cyrillic));

        assert_eq!(detect_script("aaaaa"), Some(Script::Latin));

    }

    #[test]

    fn detect_script_single_char_agrees_with_detect_char_script() {

        // Strong cross-check over the whole BMP: a 1-char text has half == 0, so the

        // first checker that claims the char wins immediately — exactly what

        // detect_char_script returns. Any divergence is a table-ordering bug.

        for ch in bmp_chars() {

            let expected = first_checker_hit(ch);

            assert_eq!(

                detect_char_script(ch),

                expected,

                "detect_char_script disagrees with SCRIPT_CHECKERS for U+{:04X}",

                ch as u32

            );

            let text = ch.to_string();

            assert_eq!(

                detect_script(&text),

                expected,

                "detect_script disagrees with detect_char_script for U+{:04X}",

                ch as u32

            );

        }

    }

    // ---------------------------------------------------------------------

    // detect_char_script (dispatch table)

    // ---------------------------------------------------------------------

    #[test]

    fn detect_char_script_extreme_inputs() {

        assert_eq!(detect_char_script('\u{0000}'), None);

        assert_eq!(detect_char_script('\u{10FFFF}'), None); // char::MAX

        assert_eq!(detect_char_script(char::MAX), None);

        assert_eq!(detect_char_script('\u{FFFF}'), None); // noncharacter

        assert_eq!(detect_char_script('\u{E000}'), None); // private use area

        assert_eq!(detect_char_script('a'), Some(Script::Latin));

        assert_eq!(detect_char_script('\u{1EE00}'), Some(Script::Arabic)); // astral Arabic

        assert_eq!(detect_char_script('\u{10E60}'), Some(Script::Arabic)); // Rumi digits

    }

    #[test]

    fn detect_char_script_astral_planes_agree_with_the_table() {

        // The two astral Arabic ranges plus the surrounding gaps, which the BMP

        // sweep above cannot reach.

        for cp in (0x1_0E00u32..=0x1_0F00).chain(0x1_ED00..=0x1_EF00).chain([

            0x1_F600, 0x2_0000, 0x10_FFFF,

        ]) {

            let Some(ch) = char::from_u32(cp) else {

                continue;

            };

            assert_eq!(

                detect_char_script(ch),

                first_checker_hit(ch),

                "astral U+{cp:05X} disagrees with SCRIPT_CHECKERS"

            );

            assert_eq!(

                detect_script(&ch.to_string()),

                first_checker_hit(ch),

                "astral U+{cp:05X}: detect_script != detect_char_script"

            );

        }

    }

    #[test]

    fn detect_char_script_none_implies_no_checker_matched() {

        for ch in bmp_chars() {

            if detect_char_script(ch).is_none() {

                for (script, check_fn) in SCRIPT_CHECKERS {

                    assert!(

                        !check_fn(ch),

                        "U+{:04X} is unclassified yet {script:?}'s checker claims it",

                        ch as u32

                    );

                }

            }

        }

    }

    #[test]

    fn detect_char_script_some_implies_that_scripts_checker_matched() {

        for ch in bmp_chars() {

            if let Some(script) = detect_char_script(ch) {

                let (_, check_fn) = SCRIPT_CHECKERS[script_index_in_table(script)];

                assert!(

                    check_fn(ch),

                    "detect_char_script said {script:?} for U+{:04X} but its checker says no",

                    ch as u32

                );

            }

        }

    }

    fn script_index_in_table(script: Script) -> usize {

        SCRIPT_CHECKERS

            .iter()

            .position(|&(s, _)| s == script)

            .expect("every Script must appear in SCRIPT_CHECKERS")

    }

    #[test]

    fn script_checkers_table_covers_every_script_exactly_once() {

        assert_eq!(SCRIPT_CHECKERS.len(), ALL_SCRIPTS.len());

        let mut seen = [0usize; 24];

        for (script, _) in SCRIPT_CHECKERS {

            seen[script_index(script)] += 1;

        }

        for (i, count) in seen.iter().enumerate() {

            assert_eq!(*count, 1, "{:?} appears {count} times in SCRIPT_CHECKERS", ALL_SCRIPTS[i]);

        }

    }

    #[test]

    fn every_script_is_reachable_from_some_bmp_char() {

        // Guards against a checker being fully shadowed by an earlier, broader one:

        // if some script can never be produced, the table order has swallowed it.

        let mut reachable = [false; 24];

        for ch in bmp_chars() {

            if let Some(script) = detect_char_script(ch) {

                reachable[script_index(script)] = true;

            }

        }

        for (i, ok) in reachable.iter().enumerate() {

            assert!(*ok, "{:?} is unreachable — shadowed by an earlier checker", ALL_SCRIPTS[i]);

        }

    }

    #[test]

    fn overlapping_ranges_resolve_to_the_first_checker_in_the_table() {

        // U+1D2B (CYRILLIC LETTER SMALL CAPITAL EL) and U+1D78 (MODIFIER LETTER

        // CYRILLIC EN) are listed by *both* is_latin (via U+1D00..=U+1D7F) and

        // is_cyrillic. Latin is checked first, so Latin wins. Pinned here because a

        // reordering of SCRIPT_CHECKERS would silently flip these to Cyrillic.

        for ch in ['\u{1D2B}', '\u{1D78}'] {

            assert!(is_latin(ch), "{ch:?} in is_latin's U+1D00..=U+1D7F range");

            assert!(is_cyrillic(ch), "{ch:?} is explicitly listed by is_cyrillic");

            assert_eq!(detect_char_script(ch), Some(Script::Latin));

            assert_eq!(detect_script(&ch.to_string()), Some(Script::Latin));

        }

    }

    // ---------------------------------------------------------------------

    // is_* predicates: exact range boundaries

    // ---------------------------------------------------------------------

    /// Assert a predicate accepts both ends and the midpoint of `[lo, hi]`. The chars

    /// bracketing the range are checked separately with `assert_rejects`, because a

    /// neighbour may legitimately belong to another range of the *same* predicate.

    fn assert_range(name: &str, f: fn(char) -> bool, lo: u32, hi: u32) {

        for cp in [lo, hi] {

            let ch = char::from_u32(cp).unwrap_or_else(|| panic!("{name}: U+{cp:04X} not a char"));

            assert!(f(ch), "{name} should accept its boundary U+{cp:04X}");

        }

        let mid = char::from_u32(lo + (hi - lo) / 2).unwrap();

        assert!(f(mid), "{name} should accept its midpoint {mid:?}");

    }

    fn assert_rejects(name: &str, f: fn(char) -> bool, cps: &[u32]) {

        for &cp in cps {

            let Some(ch) = char::from_u32(cp) else { continue };

            assert!(!f(ch), "{name} should reject U+{cp:04X}");

        }

    }

    #[test]

    fn single_range_predicates_have_exact_boundaries() {

        // (name, fn, start, end): each of these is a single contiguous block, so the

        // chars immediately before/after must be rejected.

        let cases: [(&str, fn(char) -> bool, u32, u32); 12] = [

            ("is_hebrew", is_hebrew, 0x0590, 0x05FF),

            ("is_georgian", is_georgian, 0x10A0, 0x10FF),

            ("is_bengali", is_bengali, 0x0980, 0x09FF),

            ("is_hiragana", is_hiragana, 0x3040, 0x309F),

            ("is_greek", is_greek, 0x0370, 0x03FF),

            ("is_kannada", is_kannada, 0x0C80, 0x0CFF),

            ("is_tamil", is_tamil, 0x0B80, 0x0BFF),

            ("is_thai", is_thai, 0x0E00, 0x0E7F),

            ("is_gujarati", is_gujarati, 0x0A80, 0x0AFF),

            ("is_gurmukhi", is_gurmukhi, 0x0A00, 0x0A7F),

            ("is_telugu", is_telugu, 0x0C00, 0x0C7F),

            ("is_malayalam", is_malayalam, 0x0D00, 0x0D7F),

        ];

        for (name, f, lo, hi) in cases {

            assert_range(name, f, lo, hi);

            assert_rejects(name, f, &[lo - 1, hi + 1, 0x0000, 0x0041, 0x10_FFFF]);

        }

        // The two remaining single-range predicates, spelled out (0x0B00-1 etc. all

        // land in neighbouring script blocks, which is exactly what we want to check).

        assert_range("is_oriya", is_oriya, 0x0B00, 0x0B7F);

        assert_rejects("is_oriya", is_oriya, &[0x0AFF, 0x0B80]);

        assert_range("is_myanmar", is_myanmar, 0x1000, 0x109F);

        assert_rejects("is_myanmar", is_myanmar, &[0x0FFF, 0x10A0]);

        assert_range("is_sinhala", is_sinhala, 0x0D80, 0x0DFF);

        assert_rejects("is_sinhala", is_sinhala, &[0x0D7F, 0x0E00]);

    }

    #[test]

    fn is_latin_boundaries() {

        assert!(is_latin('a') && is_latin('z') && is_latin('A') && is_latin('Z'));

        // The chars bracketing the ASCII letter ranges are all stop chars.

        assert_rejects("is_latin", is_latin, &[0x0040, 0x005B, 0x0060, 0x007B, 0x007F]);

        assert_range("is_latin", is_latin, 0x0080, 0x024F); // Latin-1 Sup .. Latin Ext-B

        assert_range("is_latin", is_latin, 0x0250, 0x02AF); // IPA extensions

        assert_rejects("is_latin", is_latin, &[0x02B0, 0x0300, 0x0400, 0x1CFF]);

        assert_range("is_latin", is_latin, 0x1D00, 0x1DBF);

        assert_rejects("is_latin", is_latin, &[0x1DC0]);

        assert_range("is_latin", is_latin, 0x1E00, 0x1EFF);

        assert_rejects("is_latin", is_latin, &[0x1DFF, 0x1F00]);

        assert_range("is_latin", is_latin, 0x2100, 0x214F);

        assert_rejects("is_latin", is_latin, &[0x20FF, 0x2150]);

        assert_range("is_latin", is_latin, 0x2C60, 0x2C7F);

        assert_rejects("is_latin", is_latin, &[0x2C5F, 0x2C80]);

        assert_range("is_latin", is_latin, 0xA720, 0xA7FF);

        assert_rejects("is_latin", is_latin, &[0xA71F, 0xA800]);

        assert_range("is_latin", is_latin, 0xAB30, 0xAB6F);

        assert_rejects("is_latin", is_latin, &[0xAB2F, 0xAB70]);

    }

    #[test]

    fn is_latin_swallows_latin1_symbols_and_letterlike_forms() {

        // Pinned quirk, not an endorsement: is_latin's U+0080..=U+00FF and

        // U+2100..=U+214F ranges are whole *blocks*, so NBSP, ©, ×, ÷, ™ and ℃ all

        // report as Latin and score for Latin in detect_script.

        for ch in ['\u{00A0}', '\u{00A9}', '\u{00D7}', '\u{00F7}', '\u{2122}', '\u{2103}'] {

            assert!(is_latin(ch), "U+{:04X} is inside is_latin's block ranges", ch as u32);

            assert_eq!(detect_script(&ch.to_string()), Some(Script::Latin));

        }

    }

    #[test]

    fn is_cyrillic_boundaries_including_the_titlo_gap() {

        assert_range("is_cyrillic", is_cyrillic, 0x0400, 0x0484);

        // U+0485/U+0486 (combining Cyrillic titlo) are deliberately excluded.

        assert_rejects("is_cyrillic", is_cyrillic, &[0x03FF, 0x0485, 0x0486, 0x0530]);

        assert_range("is_cyrillic", is_cyrillic, 0x0487, 0x052F);

        assert_range("is_cyrillic", is_cyrillic, 0x2DE0, 0x2DFF);

        assert_rejects("is_cyrillic", is_cyrillic, &[0x2DDF, 0x2E00]);

        assert_range("is_cyrillic", is_cyrillic, 0xA640, 0xA69D);

        assert!(is_cyrillic('\u{A69F}'));

        assert_rejects("is_cyrillic", is_cyrillic, &[0xA63F, 0xA69E, 0xA6A0]);

        assert!(is_cyrillic('\u{1D2B}') && is_cyrillic('\u{1D78}'));

    }

    #[test]

    fn is_arabic_boundaries_and_the_bom() {

        assert_range("is_arabic", is_arabic, 0x0600, 0x06FF);

        assert_rejects("is_arabic", is_arabic, &[0x05FF, 0x0700, 0x074F, 0x0800, 0x089F]);

        assert_range("is_arabic", is_arabic, 0x0750, 0x07FF);

        assert_range("is_arabic", is_arabic, 0x08A0, 0x08FF);

        assert_range("is_arabic", is_arabic, 0xFB50, 0xFDFF);

        assert_range("is_arabic", is_arabic, 0xFE70, 0xFEFF);

        assert_rejects("is_arabic", is_arabic, &[0xFB4F, 0xFE00, 0xFE6F, 0xFF00]);

        assert_range("is_arabic", is_arabic, 0x1_0E60, 0x1_0E7F);

        assert_range("is_arabic", is_arabic, 0x1_EE00, 0x1_EEFF);

        assert_rejects("is_arabic", is_arabic, &[0x1_0E5F, 0x1_0E80, 0x1_EDFF, 0x1_EF00]);

        // BUG PIN: U+FEFF is the byte-order mark / ZERO WIDTH NO-BREAK SPACE, whose

        // Unicode script is Common — but it sits at the top of the Arabic

        // Presentation Forms-B block, so is_arabic claims it. A BOM-prefixed text is

        // therefore scored as containing one Arabic char. Behaviour pinned as-is;

        // see the report.

        assert!(is_arabic('\u{FEFF}'));

        assert_eq!(detect_script("\u{FEFF}"), Some(Script::Arabic));

        // The BOM is not enough to beat a real majority, at least.

        assert_eq!(detect_script("\u{FEFF}hello"), Some(Script::Latin));

    }

    #[test]

    fn is_devanagari_boundaries() {

        assert_range("is_devanagari", is_devanagari, 0x0900, 0x097F);

        assert_range("is_devanagari", is_devanagari, 0xA8E0, 0xA8FF);

        assert_range("is_devanagari", is_devanagari, 0x1CD0, 0x1CFF); // Vedic extensions

        assert_rejects(

            "is_devanagari",

            is_devanagari,

            &[0x08FF, 0x0980, 0xA8DF, 0xA900, 0x1CCF, 0x1D00],

        );

    }

    #[test]

    fn is_ethiopic_boundaries() {

        assert_range("is_ethiopic", is_ethiopic, 0x1200, 0x139F);

        assert_range("is_ethiopic", is_ethiopic, 0x2D80, 0x2DDF);

        assert_range("is_ethiopic", is_ethiopic, 0xAB00, 0xAB2F);

        assert_rejects("is_ethiopic", is_ethiopic, &[0x11FF, 0x13A0, 0x2D7F, 0xAAFF]);

        // U+2DE0 is where Cyrillic Extended-A starts — must NOT be Ethiopic.

        assert!(!is_ethiopic('\u{2DE0}'));

        assert!(is_cyrillic('\u{2DE0}'));

        // U+AB30 is where is_latin's Latin Extended-E range starts.

        assert!(!is_ethiopic('\u{AB30}'));

        assert!(is_latin('\u{AB30}'));

    }

    #[test]

    fn is_mandarin_boundaries_and_gaps() {

        assert_range("is_mandarin", is_mandarin, 0x2E80, 0x2E99);

        assert!(!is_mandarin('\u{2E9A}')); // documented hole in the CJK Radicals block

        assert_range("is_mandarin", is_mandarin, 0x2E9B, 0x2EF3);

        assert_range("is_mandarin", is_mandarin, 0x2F00, 0x2FD5);

        assert!(is_mandarin('\u{3005}') && is_mandarin('\u{3007}'));

        assert!(!is_mandarin('\u{3006}')); // U+3006 IDEOGRAPHIC CLOSING MARK is excluded

        assert_range("is_mandarin", is_mandarin, 0x3021, 0x3029);

        assert_range("is_mandarin", is_mandarin, 0x3038, 0x303B);

        assert_range("is_mandarin", is_mandarin, 0x3400, 0x4DB5);

        assert_range("is_mandarin", is_mandarin, 0x4E00, 0x9FCC);

        assert_range("is_mandarin", is_mandarin, 0xF900, 0xFA6D);

        assert_range("is_mandarin", is_mandarin, 0xFA70, 0xFAD9);

        assert_rejects(

            "is_mandarin",

            is_mandarin,

            &[0x2E7F, 0x2EF4, 0x2FD6, 0x3004, 0x4DB6, 0x9FCD, 0xF8FF, 0xFA6E, 0xFADA],

        );

    }

    #[test]

    fn is_katakana_and_is_hangul_do_not_overlap_in_halfwidth_forms() {

        assert_range("is_katakana", is_katakana, 0x30A0, 0x30FF);

        assert_range("is_katakana", is_katakana, 0xFF66, 0xFF9F);

        assert_rejects("is_katakana", is_katakana, &[0x309F, 0x3100, 0xFF65, 0xFFA0]);

        assert_range("is_hangul", is_hangul, 0xAC00, 0xD7AF);

        assert_range("is_hangul", is_hangul, 0x1100, 0x11FF);

        assert_range("is_hangul", is_hangul, 0x3130, 0x318F);

        assert_range("is_hangul", is_hangul, 0xA960, 0xA97F);

        assert_range("is_hangul", is_hangul, 0xD7B0, 0xD7FF);

        assert_range("is_hangul", is_hangul, 0xFFA0, 0xFFDC);

        assert_rejects(

            "is_hangul",

            is_hangul,

            &[0x10FF, 0x1200, 0x312F, 0x3190, 0x3200, 0xABFF, 0xFF66, 0xFF9F, 0xFFDD, 0xFFE0],

        );

        // The two halfwidth ranges must stay disjoint.

        for cp in 0xFF61u32..=0xFFDCu32 {

            let ch = char::from_u32(cp).unwrap();

            assert!(

                !(is_katakana(ch) && is_hangul(ch)),

                "U+{cp:04X} claimed by both is_katakana and is_hangul"

            );

        }

    }

    #[test]

    fn is_khmer_boundaries() {

        assert_range("is_khmer", is_khmer, 0x1780, 0x17FF);

        assert_range("is_khmer", is_khmer, 0x19E0, 0x19FF);

        assert_rejects("is_khmer", is_khmer, &[0x177F, 0x1800, 0x19DF, 0x1A00]);

    }

    #[test]

    fn predicates_reject_the_extremes_and_are_pure() {

        for (script, check_fn) in SCRIPT_CHECKERS {

            for ch in ['\u{0000}', ' ', '0', '\u{007F}', '\u{10FFFF}'] {

                let first = check_fn(ch);

                assert_eq!(first, check_fn(ch), "{script:?} checker is not pure for {ch:?}");

                assert!(!first, "{script:?} checker claims the non-letter {ch:?}");

            }

        }

    }

    // ---------------------------------------------------------------------

    // detect_bengali_language

    // ---------------------------------------------------------------------

    #[test]

    fn detect_bengali_language_defaults_to_bengali() {

        assert_eq!(detect_bengali_language(""), Language::Bengali);

        assert_eq!(detect_bengali_language("   "), Language::Bengali);

        assert_eq!(detect_bengali_language("আমার সোনার বাংলা"), Language::Bengali);

        // Out-of-script text is not validated — it still falls through to Bengali.

        assert_eq!(detect_bengali_language("hello"), Language::Bengali);

        assert_eq!(detect_bengali_language("\u{1F600}"), Language::Bengali);

    }

    #[test]

    fn detect_bengali_language_finds_assamese_at_any_position() {

        for text in ["\u{09F0}", "\u{09F1}", "\u{09F0}আমার", "আমার\u{09F0}", "আ\u{09F1}র"] {

            assert_eq!(detect_bengali_language(text), Language::Assamese, "text {text:?}");

        }

        // Boundary: the code points either side of the ৰ/ৱ pair are plain Bengali.

        assert_eq!(detect_bengali_language("\u{09EF}"), Language::Bengali);

        assert_eq!(detect_bengali_language("\u{09F2}"), Language::Bengali);

    }

    #[test]

    fn detect_bengali_language_long_input_terminates() {

        let long = "আ".repeat(200_000);

        assert_eq!(detect_bengali_language(&long), Language::Bengali);

        // Assamese marker at the very end — worst case for the early-return scan.

        let mut with_marker = long.clone();

        with_marker.push('\u{09F0}');

        assert_eq!(detect_bengali_language(&with_marker), Language::Assamese);

    }

    // ---------------------------------------------------------------------

    // detect_cyrillic_language

    // ---------------------------------------------------------------------

    #[test]

    fn detect_cyrillic_language_defaults_to_russian() {