let is_case_sensitive: bool = if let Ok(case_sensitive) = dotenvy::var("CASE_SENSITIVE") {
        if let Ok(lb) = case_sensitive.parse::<LexicalBool>() {

    let is_regex: bool = if let Ok(regex) = dotenvy::var("USE_REGEX") {
        if let Ok(lb) = regex.parse::<LexicalBool>() {

            eprintln!("* The value of CASE_SENSITIVE doesn't match expected pattern!");

            eprintln!("* The value of USE_REGEX doesn't match expected pattern!");

        true

        false

    let is_case_sensitive: bool = !is_regex
        && if let Ok(case_sensitive) = dotenvy::var("CASE_SENSITIVE") {
            if let Ok(lb) = case_sensitive.parse::<LexicalBool>() {
                *lb.deref()
            } else {
                eprintln!("* The value of CASE_SENSITIVE doesn't match expected pattern!");
                return;
            }
        } else {
            true
        };

    let filter = logger::Filter::new(

    let Ok(filter) = logger::Filter::new(

    );

        is_regex,
    ) else {
        eprintln!("* Invalid regex syntax!");
        return;
    };

use regex::Regex;

    include_regex: Vec<Regex>,
    exclude_regex: Vec<Regex>,

    ) -> Filter {
        Filter {

        is_regex: bool,
    ) -> Result<Filter, &'static str> {
        let include_plain: Vec<String>;
        let exclude_plain: Vec<String>;
        let mut include_regex: Vec<Regex>;
        let mut exclude_regex: Vec<Regex>;
        if is_regex {
            include_plain = vec![];
            exclude_plain = vec![];
            include_regex = vec![];
            exclude_regex = vec![];
            for i in include {
                let Ok(re) = Regex::new(i.as_str()) else {
                    return Err("Invalid Regex");
                };
                include_regex.push(re);
            }
            for i in exclude {
                let Ok(re) = Regex::new(i.as_str()) else {
                    return Err("Invalid Regex");
                };
                exclude_regex.push(re);
            }
        } else {
            include_plain = include;
            exclude_plain = exclude;
            include_regex = vec![];
            exclude_regex = vec![];
        }
        Ok(Filter {

            include,
            exclude,

            include: include_plain,
            exclude: exclude_plain,
            include_regex,
            exclude_regex,

        }

        })

    if !settings.include_regex.is_empty()
        && settings
            .include_regex
            .into_iter()
            .filter(|x| x.is_match(&content))
            .collect::<Vec<Regex>>()
            .is_empty()
    {
        return false;
    }
    if !settings
        .exclude_regex
        .into_iter()
        .filter(|x| x.is_match(&content))
        .collect::<Vec<Regex>>()
        .is_empty()
    {
        return false;
    }

USE_REGEX=有効時、INCLUDEとEXCLUDEは正規表現として扱われます(true/false、デフォルト:false)

regex = { version = "1.10" }

 "regex",