atmos/kernel/

ime.rs

// src/ime.rs - IME (Input Method Editor) Foundation
#![allow(dead_code)]

extern crate alloc;
use alloc::string::String;
use alloc::vec::Vec;

const CONNECTION_DATA: &[u8] = include_bytes!("mozc_connection.bin");
const CONNECTION_HEADER_LEN: usize = 14;
const CONNECTION_COST_WEIGHT: i32 = 6;
const MISSING_CONNECTION_INDEX: u16 = 0xFFFF;

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum ImeMode {
    English,
    Japanese,
}

/// FEP（全角/日本語）モードが有効かどうかを描画側から参照するためのグローバルフラグ。
/// カーソル色の切り替え（半角=青系 / 全角=赤系）に使用する。
static FEP_ACTIVE: core::sync::atomic::AtomicBool = core::sync::atomic::AtomicBool::new(false);

/// FEP（全角）モードが有効かどうかを返す。
pub fn is_fep_active() -> bool {
    FEP_ACTIVE.load(core::sync::atomic::Ordering::Relaxed)
}

/// カーソル描画色を返す。全角モード時は赤系、半角時は従来の青系。
pub fn cursor_color() -> u32 {
    if is_fep_active() {
        0xFFE03C3C // 赤系（全角／FEP 有効）
    } else {
        0xFF756CE0 // 従来の青系（半角）
    }
}

#[derive(Debug, Clone)]
pub struct DictEntry {
    pub word: String,
    pub left_id: u16,
    pub right_id: u16,
    pub cost: i32,
}

#[derive(Clone)]
struct PathState {
    text: String,
    cost: i32,
    right_id: u16,
}

pub struct ImeState {
    pub mode: ImeMode,
    pub dictionary: alloc::collections::BTreeMap<String, Vec<DictEntry>>,
    pub dict_loaded: bool,
    pub composing: bool,
    pub romaji_buf: String,
    pub kana_buf: String,
    pub converting: bool,
    pub candidates: alloc::vec::Vec<String>,
    pub selected_idx: usize,
}

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

impl ImeState {
    pub const fn new() -> Self {
        Self {
            mode: ImeMode::English,
            dictionary: alloc::collections::BTreeMap::new(),
            dict_loaded: false,
            composing: false,
            romaji_buf: String::new(), // This should use String::new() instead of String::new() in const fn if not possible. But String::new() is const since 1.39.
            kana_buf: String::new(),
            converting: false,
            candidates: alloc::vec::Vec::new(),
            selected_idx: 0,
        }
    }

    pub fn load_dict(&mut self) {
        if self.dict_loaded {
            return;
        }
        crate::info!("[SYS] IME: Loading Mozc-based dictionary...");
        let s = include_str!("mozc_dict.txt");
        for line in s.lines() {
            let line = line.trim();
            if line.is_empty() || line.starts_with('#') {
                continue;
            }

            let mut cols = line.split('\t');
            let Some(yomi) = cols.next() else {
                continue;
            };
            let Some(left_id) = parse_u16(cols.next()) else {
                continue;
            };
            let Some(right_id) = parse_u16(cols.next()) else {
                continue;
            };
            let Some(cost) = parse_i32(cols.next()) else {
                continue;
            };
            let Some(word) = cols.next() else {
                continue;
            };

            if yomi.is_empty() || word.is_empty() {
                continue;
            }

            self.dictionary
                .entry(String::from(yomi))
                .or_default()
                .push(DictEntry {
                    word: String::from(word),
                    left_id,
                    right_id,
                    cost,
                });
        }
        self.dict_loaded = true;
        crate::info!(
            "IME: Loaded Mozc-based dictionary with {} readings",
            self.dictionary.len()
        );
    }

    pub fn toggle_mode(&mut self, to_japanese: bool) {
        self.load_dict(); // Ensure dict is loaded on first use

        if to_japanese {
            self.mode = ImeMode::Japanese;
        } else {
            self.mode = ImeMode::English;
        }
        FEP_ACTIVE.store(
            self.mode == ImeMode::Japanese,
            core::sync::atomic::Ordering::Relaxed,
        );
        self.clear();
    }

    pub fn clear(&mut self) {
        self.romaji_buf.clear();
        self.kana_buf.clear();
        self.composing = false;
        self.converting = false;
        self.candidates.clear();
        self.selected_idx = 0;
    }

    pub fn input_char(&mut self, c: char) {
        if self.mode == ImeMode::English {
            return;
        }

        // ローマ字入力対象: 英字 + IME テーブルに含まれる記号
        const ROMAJI_SYMBOLS: &[char] = &[
            '-', ',', '.', '/', '!', '?', '[', ']', '{', '}', '(', ')', '~',
        ];
        if c.is_ascii_alphabetic() || ROMAJI_SYMBOLS.contains(&c) {
            self.romaji_buf.push(c.to_ascii_lowercase());
            self.composing = true;
            self.convert_romaji();
        } else {
            self.kana_buf.push(c);
            self.composing = true;
        }
    }

    pub fn backspace(&mut self) {
        if !self.romaji_buf.is_empty() {
            self.romaji_buf.pop();
            self.convert_romaji();
        } else if !self.kana_buf.is_empty() {
            self.kana_buf.pop();
        }
        if self.kana_buf.is_empty() && self.romaji_buf.is_empty() {
            self.composing = false;
            self.converting = false;
            self.candidates.clear();
            self.selected_idx = 0;
        }
    }

    fn convert_romaji(&mut self) {
        let table = [
            // ---- 拗音（3文字 → 先に判定） ----
            ("kya", "きゃ"),
            ("kyu", "きゅ"),
            ("kyo", "きょ"),
            ("sha", "しゃ"),
            ("shu", "しゅ"),
            ("sho", "しょ"),
            ("sya", "しゃ"),
            ("syu", "しゅ"),
            ("syo", "しょ"),
            ("shi", "し"),
            ("cha", "ちゃ"),
            ("chu", "ちゅ"),
            ("cho", "ちょ"),
            ("chi", "ち"),
            ("tya", "ちゃ"),
            ("tyu", "ちゅ"),
            ("tyo", "ちょ"),
            ("tsu", "つ"),
            ("tu", "つ"),
            ("nya", "にゃ"),
            ("nyu", "にゅ"),
            ("nyo", "にょ"),
            ("hya", "ひゃ"),
            ("hyu", "ひゅ"),
            ("hyo", "ひょ"),
            ("mya", "みゃ"),
            ("myu", "みゅ"),
            ("myo", "みょ"),
            ("rya", "りゃ"),
            ("ryu", "りゅ"),
            ("ryo", "りょ"),
            ("gya", "ぎゃ"),
            ("gyu", "ぎゅ"),
            ("gyo", "ぎょ"),
            ("jya", "じゃ"),
            ("jyu", "じゅ"),
            ("jyo", "じょ"),
            ("zya", "じゃ"),
            ("zyu", "じゅ"),
            ("zyo", "じょ"),
            ("dya", "ぢゃ"),
            ("dyu", "ぢゅ"),
            ("dyo", "ぢょ"),
            ("bya", "びゃ"),
            ("byu", "びゅ"),
            ("byo", "びょ"),
            ("pya", "ぴゃ"),
            ("pyu", "ぴゅ"),
            ("pyo", "ぴょ"),
            // 小書き仮名 (l- prefix)
            ("la", "ぁ"),
            ("li", "ぃ"),
            ("lu", "ぅ"),
            ("le", "ぇ"),
            ("lo", "ぉ"),
            ("lya", "ゃ"),
            ("lyu", "ゅ"),
            ("lyo", "ょ"),
            ("lwa", "ゎ"),
            ("ltu", "っ"),
            ("ltsu", "っ"),
            ("xa", "ぁ"),
            ("xi", "ぃ"),
            ("xu", "ぅ"),
            ("xe", "ぇ"),
            ("xo", "ぉ"),
            ("xya", "ゃ"),
            ("xyu", "ゅ"),
            ("xyo", "ょ"),
            ("xtu", "っ"),
            ("xtsu", "っ"),
            // ---- 母音 ----
            ("a", "あ"),
            ("i", "い"),
            ("u", "う"),
            ("e", "え"),
            ("o", "お"),
            // ---- か行 ----
            ("ka", "か"),
            ("ki", "き"),
            ("ku", "く"),
            ("ke", "け"),
            ("ko", "こ"),
            // ---- さ行 ----
            ("sa", "さ"),
            ("si", "し"),
            ("su", "す"),
            ("se", "せ"),
            ("so", "そ"),
            // ---- た行 ----
            ("ta", "た"),
            ("ti", "ち"),
            ("te", "て"),
            ("to", "と"),
            // ---- な行 ----
            ("na", "な"),
            ("ni", "に"),
            ("nu", "ぬ"),
            ("ne", "ね"),
            ("no", "の"),
            // ---- は行 ----
            ("ha", "は"),
            ("hi", "ひ"),
            ("fu", "ふ"),
            ("hu", "ふ"),
            ("he", "へ"),
            ("ho", "ほ"),
            // ---- ま行 ----
            ("ma", "ま"),
            ("mi", "み"),
            ("mu", "む"),
            ("me", "め"),
            ("mo", "も"),
            // ---- や行 ----
            ("ya", "や"),
            ("yu", "ゆ"),
            ("yo", "よ"),
            // ---- ら行 ----
            ("ra", "ら"),
            ("ri", "り"),
            ("ru", "る"),
            ("re", "れ"),
            ("ro", "ろ"),
            // ---- わ行・ん ----
            ("wa", "わ"),
            ("wi", "ゐ"),
            ("we", "ゑ"),
            ("wo", "を"),
            ("wha", "うぁ"),
            ("whi", "うぃ"),
            ("whe", "うぇ"),
            ("who", "うぉ"),
            // ---- が行 ----
            ("ga", "が"),
            ("gi", "ぎ"),
            ("gu", "ぐ"),
            ("ge", "げ"),
            ("go", "ご"),
            // ---- ざ行 ----
            ("za", "ざ"),
            ("ji", "じ"),
            ("zi", "じ"),
            ("zu", "ず"),
            ("ze", "ぜ"),
            ("zo", "ぞ"),
            ("ja", "じゃ"),
            ("ju", "じゅ"),
            ("jo", "じょ"),
            // ---- だ行 ----
            ("da", "だ"),
            ("di", "ぢ"),
            ("du", "づ"),
            ("de", "で"),
            ("do", "ど"),
            // ---- ば行 ----
            ("ba", "ば"),
            ("bi", "び"),
            ("bu", "ぶ"),
            ("be", "べ"),
            ("bo", "ぼ"),
            // ---- ぱ行 ----
            ("pa", "ぱ"),
            ("pi", "ぴ"),
            ("pu", "ぷ"),
            ("pe", "ぺ"),
            ("po", "ぽ"),
            // ---- ヴ行（外来語） ----
            ("va", "ヴぁ"),
            ("vi", "ヴぃ"),
            ("vu", "ヴ"),
            ("ve", "ヴぇ"),
            ("vo", "ヴぉ"),
            // ---- ファ行（外来語） ----
            ("fa", "ふぁ"),
            ("fi", "ふぃ"),
            ("fe", "ふぇ"),
            ("fo", "ふぉ"),
            // ---- ティ・ディ（外来語） ----
            ("thi", "てぃ"),
            ("dhi", "でぃ"),
            ("dhu", "どぅ"),
            ("dho", "どぉ"),
            ("twu", "とぅ"),
            // ---- 記号・句読点 ----
            (",", "、"),
            (".", "。"),
            ("/", "・"),
            ("!", "！"),
            ("?", "？"),
            ("[", "「"),
            ("]", "」"),
            ("{", "『"),
            ("}", "』"),
            ("(", "（"),
            (")", "）"),
            // ---- 長音符・その他 ----
            ("-", "ー"),
            ("~", "〜"),
        ];

        let mut temp_kana = String::new();
        let mut romaji = self.romaji_buf.clone();

        loop {
            let mut matched = false;
            for (rom, kana) in table.iter() {
                if romaji.starts_with(rom) {
                    temp_kana.push_str(kana);
                    romaji = String::from(romaji.get(rom.len()..).unwrap_or(""));
                    matched = true;
                    break;
                }
            }
            if !matched {
                // 促音化（っ）: 同じ子音の連続。ただし 'n' は撥音（ん）扱いなので除外。
                if romaji.len() > 1
                    && romaji.as_bytes()[0] != b'n'
                    && romaji.as_bytes()[0] == romaji.as_bytes()[1]
                {
                    temp_kana.push('っ');
                    romaji = String::from(romaji.get(1..).unwrap_or(""));
                } else if starts_with_n_before_consonant(&romaji) {
                    temp_kana.push('ん');
                    romaji = String::from(romaji.get(1..).unwrap_or(""));
                } else {
                    break;
                }
            }
        }

        if !temp_kana.is_empty() {
            self.kana_buf.push_str(&temp_kana);
            self.romaji_buf = romaji;
        }
    }

    fn flush_pending_romaji(&mut self) {
        if self.romaji_buf == "n" {
            self.kana_buf.push('ん');
            self.romaji_buf.clear();
        }
    }

    pub fn handle_space(&mut self) -> bool {
        if !self.composing {
            return false;
        }

        self.flush_pending_romaji();

        if !self.converting {
            // First time pressing space -> start conversion
            self.candidates.clear();

            self.build_conversion_candidates();

            // 変換不能でも入力を確定できるよう、元のひらがなを候補に追加
            let hiragana = self.kana_buf.clone();
            if !self.candidates.contains(&hiragana) {
                self.candidates.push(hiragana);
            }

            // カタカナ変換結果を候補に追加
            let katakana = to_katakana(&self.kana_buf);
            if !self.candidates.contains(&katakana) {
                self.candidates.push(katakana);
            }

            self.converting = true;
            self.selected_idx = 0;
        } else {
            // Already converting -> next candidate
            if !self.candidates.is_empty() {
                self.selected_idx = (self.selected_idx + 1) % self.candidates.len();
            }
        }
        true
    }

    fn build_conversion_candidates(&mut self) {
        const BEAM_WIDTH: usize = 8;
        const MAX_CANDIDATES: usize = 12;
        const UNKNOWN_COST: i32 = 12000;
        const SEGMENT_COST: i32 = 1000;

        let input = self.kana_buf.as_str();
        let positions = byte_positions(input);
        if positions.len() <= 1 {
            return;
        }

        let mut lattice: Vec<Vec<PathState>> = Vec::new();
        for _ in 0..positions.len() {
            lattice.push(Vec::new());
        }
        lattice[0].push(PathState {
            text: String::new(),
            cost: 0,
            right_id: 0,
        });

        for start_idx in 0..positions.len() - 1 {
            if lattice[start_idx].is_empty() {
                continue;
            }

            let start_byte = positions[start_idx];
            let states = lattice[start_idx].clone();

            for end_idx in start_idx + 1..positions.len() {
                let end_byte = positions[end_idx];
                let yomi = input.get(start_byte..end_byte).unwrap_or("");

                if let Some(entries) = self.dictionary.get(yomi) {
                    for state in states.iter() {
                        for entry in entries {
                            let mut text = state.text.clone();
                            text.push_str(&entry.word);
                            let cost = state.cost
                                + adjusted_entry_cost(yomi, entry)
                                + transition_cost(state.right_id, entry.left_id)
                                + SEGMENT_COST;
                            push_beam(
                                &mut lattice[end_idx],
                                PathState {
                                    text,
                                    cost,
                                    right_id: entry.right_id,
                                },
                                BEAM_WIDTH,
                            );
                        }
                    }
                }
            }

            let next_byte = positions[start_idx + 1];
            let unknown = input.get(start_byte..next_byte).unwrap_or("");
            for state in states.iter() {
                let mut text = state.text.clone();
                text.push_str(unknown);
                push_beam(
                    &mut lattice[start_idx + 1],
                    PathState {
                        text,
                        cost: state.cost + UNKNOWN_COST,
                        right_id: 0,
                    },
                    BEAM_WIDTH,
                );
            }
        }

        let Some(final_states) = lattice.last_mut() else {
            return;
        };
        final_states.sort_by_key(|state| state.cost);

        for state in final_states.iter() {
            if self.candidates.len() >= MAX_CANDIDATES {
                break;
            }
            if !self.candidates.contains(&state.text) {
                self.candidates.push(state.text.clone());
            }
        }
    }

    pub fn handle_enter(&mut self) -> Option<String> {
        self.flush_pending_romaji();

        if self.converting {
            // 候補が空/範囲外でもパニックしないよう get で安全に取り出す。
            let res = self
                .candidates
                .get(self.selected_idx)
                .cloned()
                .unwrap_or_else(|| self.kana_buf.clone());
            self.clear();
            Some(res)
        } else if self.composing {
            let res = self.kana_buf.clone();
            self.clear();
            Some(res)
        } else {
            None
        }
    }

    /// Escape キー: 変換中なら変換をキャンセルしてひらがなに戻る。未変換なら全クリア。
    pub fn cancel(&mut self) {
        if self.converting {
            self.converting = false;
            self.candidates.clear();
            self.selected_idx = 0;
            // kana_buf はそのまま残す（ひらがな入力状態に戻る）
        } else {
            self.clear();
        }
    }

    /// 数字キー(1〜9)で候補を直接選択して確定。確定テキストを返す。
    pub fn select_candidate_by_number(&mut self, n: usize) -> Option<String> {
        if !self.converting || self.candidates.is_empty() {
            return None;
        }
        let idx = n.saturating_sub(1); // 1→0, 2→1, ...
        if idx < self.candidates.len() {
            let res = self.candidates[idx].clone();
            self.clear();
            Some(res)
        } else {
            None
        }
    }

    pub fn get_display_text(&self) -> String {
        if self.converting && !self.candidates.is_empty() {
            self.candidates[self.selected_idx].clone()
        } else {
            self.kana_buf.clone() + &self.romaji_buf
        }
    }
}

/// IME の自己テスト。ローマ字→かな変換と、かな→漢字変換（Mozc 辞書＋ラティス）を検証する。
/// 起動時に `IME_SELFTEST: PASS n/n` を出す（CI スモークの判定マーカー）。
pub fn selftest() -> (usize, usize) {
    // ローマ字 → ひらがな（辞書不要・決定的）。
    let kana_cases: &[(&str, &str)] = &[
        ("nihon", "にほん"),
        ("konnichiha", "こんにちは"),
        ("gakkou", "がっこう"),
        ("denwa", "でんわ"),
        ("kanji", "かんじ"),
        ("kya", "きゃ"),
        ("sha", "しゃ"),
        ("chi", "ち"),
        ("tte", "って"),
        ("shinbun", "しんぶん"),
        ("wo", "を"),
        ("sakka", "さっか"),
        ("zasshi", "ざっし"),
        ("annai", "あんない"),
    ];
    // かな（ローマ字入力経由）→ 漢字。候補に期待語が含まれるか。
    let conv_cases: &[(&str, &str)] = &[
        ("nihon", "日本"),
        ("denwa", "電話"),
        ("gakkou", "学校"),
        ("kanji", "漢字"),
    ];

    let mut passed = 0;
    let total = kana_cases.len() + conv_cases.len();

    // 辞書ロードは高コスト（約 7.8 万エントリ）なので 1 度だけ行い、ケース間は clear() で再利用する。
    let mut ime = ImeState::new();
    ime.toggle_mode(true); // 日本語モード（辞書ロード込み・1 回のみ）

    for (rom, kana) in kana_cases {
        ime.clear();
        for c in rom.chars() {
            ime.input_char(c);
        }
        ime.flush_pending_romaji();
        if &ime.kana_buf == kana {
            passed += 1;
        } else {
            crate::println!(
                "IME_SELFTEST FAIL: `{}` => `{}` (want `{}`)",
                rom,
                ime.kana_buf,
                kana
            );
        }
    }

    for (rom, kanji) in conv_cases {
        ime.clear();
        for c in rom.chars() {
            ime.input_char(c);
        }
        ime.handle_space();
        if ime.candidates.iter().any(|c| c == kanji) {
            passed += 1;
        } else {
            crate::println!(
                "IME_SELFTEST FAIL: convert `{}` missing `{}` (got {:?})",
                rom,
                kanji,
                ime.candidates
            );
        }
    }

    (passed, total)
}

fn parse_u16(s: Option<&str>) -> Option<u16> {
    s?.parse::<u16>().ok()
}

fn parse_i32(s: Option<&str>) -> Option<i32> {
    s?.parse::<i32>().ok()
}

fn byte_positions(s: &str) -> Vec<usize> {
    let mut positions = Vec::new();
    positions.push(0);
    for (idx, _) in s.char_indices().skip(1) {
        positions.push(idx);
    }
    positions.push(s.len());
    positions
}

fn transition_cost(prev_right_id: u16, left_id: u16) -> i32 {
    mozc_connection_cost(prev_right_id, left_id)
        .map(|cost| cost / CONNECTION_COST_WEIGHT)
        .unwrap_or_else(|| {
            if prev_right_id == 0 || left_id == 0 {
                0
            } else if prev_right_id == left_id {
                40
            } else {
                220
            }
        })
}

fn mozc_connection_cost(prev_right_id: u16, left_id: u16) -> Option<i32> {
    if CONNECTION_DATA.len() < CONNECTION_HEADER_LEN || &CONNECTION_DATA[..8] != b"MOZCCON1" {
        return None;
    }

    let context_count = read_u16(CONNECTION_DATA, 8)? as usize;
    let right_count = read_u16(CONNECTION_DATA, 10)? as usize;
    let left_count = read_u16(CONNECTION_DATA, 12)? as usize;
    let prev_right_id = prev_right_id as usize;
    let left_id = left_id as usize;

    if prev_right_id >= context_count || left_id >= context_count {
        return None;
    }

    let right_lookup_offset = CONNECTION_HEADER_LEN;
    let left_lookup_offset = right_lookup_offset + context_count * 2;
    let matrix_offset = left_lookup_offset + context_count * 2;
    let right_index = read_u16(CONNECTION_DATA, right_lookup_offset + prev_right_id * 2)?;
    let left_index = read_u16(CONNECTION_DATA, left_lookup_offset + left_id * 2)?;

    if right_index == MISSING_CONNECTION_INDEX || left_index == MISSING_CONNECTION_INDEX {
        return None;
    }

    let right_index = right_index as usize;
    let left_index = left_index as usize;
    if right_index >= right_count || left_index >= left_count {
        return None;
    }

    let cost_offset = matrix_offset + (right_index * left_count + left_index) * 2;
    read_u16(CONNECTION_DATA, cost_offset).map(|cost| cost as i32)
}

fn adjusted_entry_cost(yomi: &str, entry: &DictEntry) -> i32 {
    let mut cost = entry.cost;
    let yomi_len = yomi.chars().count() as i32;
    if entry.word.chars().all(is_hiragana) && !prefers_hiragana(yomi) {
        cost += 2500;
    }
    if yomi_len == 1 && !entry.word.chars().all(is_hiragana) {
        cost += 1500;
    }
    if yomi_len > 1 && entry.word.chars().all(is_katakana) {
        cost += 1000;
    }
    cost -= (yomi_len - 1).max(0) * 1000;
    cost
}

fn push_beam(beam: &mut Vec<PathState>, state: PathState, limit: usize) {
    if let Some(existing) = beam
        .iter_mut()
        .find(|candidate| candidate.text == state.text)
    {
        if state.cost < existing.cost {
            *existing = state;
        }
    } else {
        beam.push(state);
    }

    beam.sort_by_key(|candidate| candidate.cost);
    if beam.len() > limit {
        beam.truncate(limit);
    }
}

fn starts_with_n_before_consonant(s: &str) -> bool {
    if !s.starts_with('n') || s.len() < 2 {
        return false;
    }

    let next = s.as_bytes()[1] as char;
    // 母音・y 以外の子音が続けば撥音「ん」。`nn` も撥音（n を 1 つ消費し、
    // 残り 1 つは次の母音と結合: konnichiha → こんにちは）。
    !matches!(next, 'a' | 'i' | 'u' | 'e' | 'o' | 'y')
}

fn read_u16(bytes: &[u8], offset: usize) -> Option<u16> {
    if offset + 1 >= bytes.len() {
        None
    } else {
        Some(u16::from_le_bytes([bytes[offset], bytes[offset + 1]]))
    }
}

fn is_hiragana(c: char) -> bool {
    ('\u{3041}'..='\u{3096}').contains(&c)
}

fn is_katakana(c: char) -> bool {
    ('\u{30A1}'..='\u{30FA}').contains(&c) || c == 'ー'
}

fn prefers_hiragana(s: &str) -> bool {
    matches!(
        s,
        "は" | "が"
            | "を"
            | "に"
            | "へ"
            | "と"
            | "で"
            | "も"
            | "の"
            | "や"
            | "ね"
            | "よ"
            | "です"
            | "ます"
            | "でした"
            | "ません"
            | "ない"
            | "いい"
    )
}

// ひらがなをカタカナに変換するヘルパー関数
fn to_katakana(s: &str) -> String {
    let mut res = String::new();
    for c in s.chars() {
        if ('\u{3041}'..='\u{3096}').contains(&c) {
            if let Some(kc) = core::char::from_u32(c as u32 + 0x60) {
                res.push(kc);
            } else {
                res.push(c);
            }
        } else {
            res.push(c);
        }
    }
    res
}