diff --git a/charabia/Cargo.toml b/charabia/Cargo.toml
index 6086c9ce..69562d5b 100644
--- a/charabia/Cargo.toml
+++ b/charabia/Cargo.toml
@@ -13,15 +13,13 @@ exclude = ["dictionaries/txt/thai/words.txt"]
 
 [dependencies]
 aho-corasick = "1.1.3"
-cow-utils = "0.1"
 csv = "1.3.0"
-deunicode = "1.6.0"
 either = "1.13.0"
 finl_unicode = { version= "1.2.0", optional = true }
 fst = "0.4"
 jieba-rs = { version = "0.7", optional = true }
 once_cell = "1.19.0"
-serde = "1.0"
+serde = "1.0.192"
 slice-group-by = "0.3.1"
 whatlang = "0.16.4"
 lindera = { version = "=0.32.2", default-features = false, optional = true }
@@ -31,8 +29,6 @@ pinyin = { version = "0.10", default-features = false, features = [
 wana_kana = { version = "3.0.0", optional = true }
 unicode-normalization = "0.1.23"
 irg-kvariants = { path = "../irg-kvariants", version = "=0.1.1" }
-litemap = "0.7.3"
-zerovec = "0.10.4"
 
 [features]
 default = ["chinese", "hebrew", "japanese", "thai", "korean", "greek", "latin-camelcase", "latin-snakecase", "khmer", "vietnamese"]
diff --git a/charabia/src/detection/mod.rs b/charabia/src/detection/mod.rs
index 0c5781b0..3bfa5d53 100644
--- a/charabia/src/detection/mod.rs
+++ b/charabia/src/detection/mod.rs
@@ -1,5 +1,3 @@
-use std::collections::HashMap;
-
 pub use script_language::{Language, Script};
 use whatlang::Detector;
 
@@ -12,11 +10,11 @@ pub struct StrDetection<'o, 'al> {
     inner: &'o str,
     pub script: Option<Script>,
     pub language: Option<Language>,
-    allow_list: Option<&'al HashMap<Script, Vec<Language>>>,
+    allow_list: Option<&'al [Language]>,
 }
 
 impl<'o, 'al> StrDetection<'o, 'al> {
-    pub fn new(inner: &'o str, allow_list: Option<&'al HashMap<Script, Vec<Language>>>) -> Self {
+    pub fn new(inner: &'o str, allow_list: Option<&'al [Language]>) -> Self {
         Self { inner, script: None, language: None, allow_list }
     }
 
@@ -25,10 +23,14 @@ impl<'o, 'al> StrDetection<'o, 'al> {
         *self.script.get_or_insert_with(|| Self::detect_script(inner))
     }
 
-    pub fn language(&mut self) -> Language {
+    pub fn language(&mut self) -> Option<Language> {
         let inner = self.inner;
-        let script = self.script();
-        *self.language.get_or_insert_with(|| Self::detect_lang(inner, script, self.allow_list))
+        self.language = match self.language.take() {
+            Some(lang) => Some(lang),
+            None => Self::detect_lang(inner, self.allow_list),
+        };
+
+        self.language
     }
 
     /// detect script with whatlang,
@@ -39,33 +41,22 @@ impl<'o, 'al> StrDetection<'o, 'al> {
 
     /// detect lang with whatlang
     /// if no language is detected, return Language::Other
-    fn detect_lang(
-        text: &str,
-        script: Script,
-        allow_list: Option<&HashMap<Script, Vec<Language>>>,
-    ) -> Language {
+    fn detect_lang(text: &str, allow_list: Option<&[Language]>) -> Option<Language> {
         let detector = allow_list
-            .and_then(|allow_list| allow_list.get(&script))
             .map(|allow_list| allow_list.iter().map(|lang| (*lang).into()).collect())
             .map(Detector::with_allowlist)
             .unwrap_or_default();
 
-        detector.detect_lang(text).map(Language::from).unwrap_or_default()
+        detector.detect_lang(text).map(Language::from)
     }
 }
 
 pub trait Detect<'o, 'al> {
-    fn detect(
-        &'o self,
-        allow_list: Option<&'al HashMap<Script, Vec<Language>>>,
-    ) -> StrDetection<'o, 'al>;
+    fn detect(&'o self, allow_list: Option<&'al [Language]>) -> StrDetection<'o, 'al>;
 }
 
 impl<'o, 'al> Detect<'o, 'al> for &str {
-    fn detect(
-        &'o self,
-        allow_list: Option<&'al HashMap<Script, Vec<Language>>>,
-    ) -> StrDetection<'o, 'al> {
+    fn detect(&'o self, allow_list: Option<&'al [Language]>) -> StrDetection<'o, 'al> {
         StrDetection::new(self, allow_list)
     }
 }
diff --git a/charabia/src/detection/script_language.rs b/charabia/src/detection/script_language.rs
index 96bea342..1c904d87 100644
--- a/charabia/src/detection/script_language.rs
+++ b/charabia/src/detection/script_language.rs
@@ -2,15 +2,15 @@ use core::str::FromStr;
 
 #[cfg(test)]
 use quickcheck::{Arbitrary, Gen};
+use serde::{Deserialize, Serialize};
 
 use super::chars;
 
 macro_rules! make_language {
     ($($language:tt), +) => {
-        #[derive(Debug, PartialEq, Eq, Hash, Clone, Copy)]
+        #[derive(Debug, PartialEq, Eq, Hash, Clone, Copy, Serialize, Deserialize, PartialOrd, Ord)]
         pub enum Language {
             $($language),+,
-            Other,
         }
         impl From<whatlang::Lang> for Language {
             fn from(other: whatlang::Lang) -> Language {
@@ -24,27 +24,19 @@ macro_rules! make_language {
             fn from(other: Language) -> whatlang::Lang {
                 match other {
                     $(Language::$language => whatlang::Lang::$language), +,
-                    _other => whatlang::Lang::Eng,
                 }
             }
         }
 
-        impl Default for Language {
-            fn default() -> Self {
-                Self::Other
-            }
-        }
-
         impl Language {
-            pub fn name(&self) -> &'static str {
+            pub fn code(&self) -> &'static str {
                 match self {
                     $(Language::$language => whatlang::Lang::$language.code()), +,
-                    _other => "other",
                 }
             }
 
-            pub fn from_name<S: AsRef<str>>(code: S) -> Language {
-                whatlang::Lang::from_code(code.as_ref()).map(Language::from).unwrap_or_default()
+            pub fn from_code<S: AsRef<str>>(code: S) -> Option<Language> {
+                whatlang::Lang::from_code(code.as_ref()).map(Language::from)
             }
         }
     };
@@ -124,7 +116,7 @@ make_language! {
 
 macro_rules! make_script {
     ($($script:tt), +) => {
-        #[derive(Debug, PartialEq, Eq, Hash, Clone, Copy)]
+        #[derive(Debug, PartialEq, Eq, Hash, Clone, Copy, Serialize, Deserialize, PartialOrd, Ord)]
         pub enum Script {
             $($script),+,
             Cj,
@@ -361,12 +353,12 @@ mod test {
 
     #[test]
     fn from_into_language() {
-        assert_eq!(Language::Eng.name(), "eng");
-        assert_eq!(Language::from_name("eng"), Language::Eng);
-        assert_eq!(Language::Jpn.name(), "jpn");
-        assert_eq!(Language::from_name("jpn"), Language::Jpn);
-        assert_eq!(Language::Cmn.name(), "cmn");
-        assert_eq!(Language::from_name("cmn"), Language::Cmn);
+        assert_eq!(Language::Eng.code(), "eng");
+        assert_eq!(Language::from_code("eng"), Some(Language::Eng));
+        assert_eq!(Language::Jpn.code(), "jpn");
+        assert_eq!(Language::from_code("jpn"), Some(Language::Jpn));
+        assert_eq!(Language::Cmn.code(), "cmn");
+        assert_eq!(Language::from_code("cmn"), Some(Language::Cmn));
     }
 
     #[test]
diff --git a/charabia/src/lib.rs b/charabia/src/lib.rs
index bfabcde1..0d2a5ac0 100644
--- a/charabia/src/lib.rs
+++ b/charabia/src/lib.rs
@@ -56,7 +56,7 @@ mod detection;
 mod token;
 mod tokenizer;
 
-pub use detection::{Language, Script};
+pub use detection::{Language, Script, StrDetection};
 pub use normalizer::Normalize;
 pub use segmenter::Segment;
 pub use token::{SeparatorKind, Token, TokenKind};
diff --git a/charabia/src/normalizer/mod.rs b/charabia/src/normalizer/mod.rs
index e4551961..fa28e83c 100644
--- a/charabia/src/normalizer/mod.rs
+++ b/charabia/src/normalizer/mod.rs
@@ -81,12 +81,12 @@ pub(crate) const DEFAULT_NORMALIZER_OPTION: NormalizerOption = NormalizerOption
 };
 
 /// Iterator over Normalized [`Token`]s.
-pub struct NormalizedTokenIter<'o, 'tb> {
-    token_iter: SegmentedTokenIter<'o, 'tb>,
+pub struct NormalizedTokenIter<'o, 'aho, 'lang, 'tb> {
+    token_iter: SegmentedTokenIter<'o, 'aho, 'lang>,
     options: &'tb NormalizerOption<'tb>,
 }
 
-impl<'o> Iterator for NormalizedTokenIter<'o, '_> {
+impl<'o> Iterator for NormalizedTokenIter<'o, '_, '_, '_> {
     type Item = Token<'o>;
 
     fn next(&mut self) -> Option<Self::Item> {
@@ -232,11 +232,14 @@ impl From<String> for CharOrStr {
     }
 }
 
-impl<'o, 'tb> SegmentedTokenIter<'o, 'tb> {
+impl<'o, 'aho, 'lang> SegmentedTokenIter<'o, 'aho, 'lang> {
     /// Normalize [`Token`]s using all the compatible Normalizers.
     ///
     /// A Latin `Token` would not be normalized the same as a Chinese `Token`.
-    pub fn normalize(self, options: &'tb NormalizerOption<'tb>) -> NormalizedTokenIter<'o, 'tb> {
+    pub fn normalize<'tb>(
+        self,
+        options: &'tb NormalizerOption<'tb>,
+    ) -> NormalizedTokenIter<'o, 'aho, 'lang, 'tb> {
         NormalizedTokenIter { token_iter: self, options }
     }
 }
diff --git a/charabia/src/normalizer/swedish_recomposition.rs b/charabia/src/normalizer/swedish_recomposition.rs
index 298ab60a..9a38da41 100644
--- a/charabia/src/normalizer/swedish_recomposition.rs
+++ b/charabia/src/normalizer/swedish_recomposition.rs
@@ -5,7 +5,7 @@ use once_cell::sync::Lazy;
 
 use super::Normalizer;
 use crate::normalizer::NormalizerOption;
-use crate::{Script, Token};
+use crate::{Language, Token};
 
 static MATCHING_STR: Lazy<AhoCorasick> = Lazy::new(|| {
     AhoCorasick::new(&["A\u{30a}", "a\u{30a}", "A\u{308}", "a\u{308}", "O\u{308}", "o\u{308}"])
@@ -77,7 +77,7 @@ impl Normalizer for SwedishRecompositionNormalizer {
 
     // Returns `true` if the Normalizer should be used.
     fn should_normalize(&self, token: &Token) -> bool {
-        token.script == Script::Latin && MATCHING_STR.is_match(token.lemma())
+        token.language == Some(Language::Swe) && MATCHING_STR.is_match(token.lemma())
     }
 }
 
@@ -101,6 +101,7 @@ mod test {
     use crate::normalizer::test::test_normalizer;
     use crate::normalizer::Normalizer;
     use crate::token::TokenKind;
+    use crate::Script;
 
     // base tokens to normalize.
     fn tokens() -> Vec<Token<'static>> {
@@ -109,6 +110,7 @@ mod test {
             char_end: 13,
             byte_end: 19,
             script: Script::Latin,
+            language: Some(Language::Swe),
             ..Default::default()
         }]
     }
@@ -121,6 +123,7 @@ mod test {
             char_end: 13,
             byte_end: 19,
             script: Script::Latin,
+            language: Some(Language::Swe),
             ..Default::default()
         }]
     }
@@ -148,6 +151,7 @@ mod test {
             ]),
             script: Script::Latin,
             kind: TokenKind::Word,
+            language: Some(Language::Swe),
             ..Default::default()
         }]
     }
diff --git a/charabia/src/segmenter/latin/mod.rs b/charabia/src/segmenter/latin/mod.rs
index 88a9fafa..7f978c18 100644
--- a/charabia/src/segmenter/latin/mod.rs
+++ b/charabia/src/segmenter/latin/mod.rs
@@ -40,5 +40,5 @@ mod test {
         "snake", "_", "case",
     ];
 
-    test_segmenter!(LatinSegmenter, TEXT, SEGMENTED, TOKENIZED, Script::Latin, Language::Other);
+    test_segmenter!(LatinSegmenter, TEXT, SEGMENTED, TOKENIZED, Script::Latin, Language::Eng);
 }
diff --git a/charabia/src/segmenter/mod.rs b/charabia/src/segmenter/mod.rs
index 579d3389..f41f18aa 100644
--- a/charabia/src/segmenter/mod.rs
+++ b/charabia/src/segmenter/mod.rs
@@ -37,6 +37,8 @@ mod thai;
 #[cfg(any(feature = "thai", feature = "khmer"))]
 mod utils;
 
+pub type SegmenterMap = HashMap<(Script, Option<Language>), Box<dyn Segmenter>>;
+
 /// List of used [`Segmenter`]s linked to their corresponding [`Script`] and [`Language`].
 ///
 /// This list is used after `Script` and `Language` detection to pick the specialized [`Segmenter`].
@@ -48,26 +50,28 @@ mod utils;
 /// A segmenter assigned to `Language::Other` is considered as the default `Segmenter` for any `Language` that uses the assigned `Script`.
 /// For example, [`LatinSegmenter`] is assigned to `(Script::Latin, Language::Other)`,
 /// meaning that `LatinSegmenter` is the default `Segmenter` for any `Language` that uses `Latin` `Script`.
-pub static SEGMENTERS: Lazy<HashMap<(Script, Language), Box<dyn Segmenter>>> = Lazy::new(|| {
+pub static SEGMENTERS: Lazy<SegmenterMap> = Lazy::new(|| {
     vec![
         // latin segmenter
-        ((Script::Latin, Language::Other), Box::new(LatinSegmenter) as Box<dyn Segmenter>),
+        ((Script::Latin, None), Box::new(LatinSegmenter) as Box<dyn Segmenter>),
+        #[cfg(feature = "swedish-recomposition")]
+        ((Script::Latin, Some(Language::Swe)), Box::new(LatinSegmenter) as Box<dyn Segmenter>),
         // chinese segmenter
         #[cfg(feature = "chinese-segmentation")]
-        ((Script::Cj, Language::Cmn), Box::new(ChineseSegmenter) as Box<dyn Segmenter>),
+        ((Script::Cj, Some(Language::Cmn)), Box::new(ChineseSegmenter) as Box<dyn Segmenter>),
         // japanese segmenter
         #[cfg(feature = "japanese")]
-        ((Script::Cj, Language::Jpn), Box::new(JapaneseSegmenter) as Box<dyn Segmenter>),
+        ((Script::Cj, Some(Language::Jpn)), Box::new(JapaneseSegmenter) as Box<dyn Segmenter>),
         // korean segmenter
         #[cfg(feature = "korean")]
-        ((Script::Hangul, Language::Kor), Box::new(KoreanSegmenter) as Box<dyn Segmenter>),
+        ((Script::Hangul, Some(Language::Kor)), Box::new(KoreanSegmenter) as Box<dyn Segmenter>),
         // thai segmenter
         #[cfg(feature = "thai")]
-        ((Script::Thai, Language::Tha), Box::new(ThaiSegmenter) as Box<dyn Segmenter>),
+        ((Script::Thai, Some(Language::Tha)), Box::new(ThaiSegmenter) as Box<dyn Segmenter>),
         #[cfg(feature = "khmer")]
-        ((Script::Khmer, Language::Khm), Box::new(KhmerSegmenter) as Box<dyn Segmenter>),
+        ((Script::Khmer, Some(Language::Khm)), Box::new(KhmerSegmenter) as Box<dyn Segmenter>),
         // arabic segmenter
-        ((Script::Arabic, Language::Ara), Box::new(ArabicSegmenter) as Box<dyn Segmenter>),
+        ((Script::Arabic, Some(Language::Ara)), Box::new(ArabicSegmenter) as Box<dyn Segmenter>),
     ]
     .into_iter()
     .collect()
@@ -81,13 +85,13 @@ pub static DEFAULT_SEPARATOR_AHO: Lazy<AhoCorasick> = Lazy::new(|| {
 });
 
 /// Iterator over segmented [`Token`]s.
-pub struct SegmentedTokenIter<'o, 'tb> {
-    inner: SegmentedStrIter<'o, 'tb>,
+pub struct SegmentedTokenIter<'o, 'aho, 'lang> {
+    inner: SegmentedStrIter<'o, 'aho, 'lang>,
     char_index: usize,
     byte_index: usize,
 }
 
-impl<'o> Iterator for SegmentedTokenIter<'o, '_> {
+impl<'o> Iterator for SegmentedTokenIter<'o, '_, '_> {
     type Item = Token<'o>;
 
     fn next(&mut self) -> Option<Self::Item> {
@@ -111,24 +115,31 @@ impl<'o> Iterator for SegmentedTokenIter<'o, '_> {
     }
 }
 
-impl<'o, 'tb> From<SegmentedStrIter<'o, 'tb>> for SegmentedTokenIter<'o, 'tb> {
-    fn from(segmented_str_iter: SegmentedStrIter<'o, 'tb>) -> Self {
+impl<'o, 'aho, 'lang> From<SegmentedStrIter<'o, 'aho, 'lang>>
+    for SegmentedTokenIter<'o, 'aho, 'lang>
+{
+    fn from(segmented_str_iter: SegmentedStrIter<'o, 'aho, 'lang>) -> Self {
         Self { inner: segmented_str_iter, char_index: 0, byte_index: 0 }
     }
 }
 
-pub struct SegmentedStrIter<'o, 'tb> {
+pub struct SegmentedStrIter<'o, 'aho, 'lang> {
     inner: Box<dyn Iterator<Item = &'o str> + 'o>,
     current: Box<dyn Iterator<Item = &'o str> + 'o>,
-    aho_iter: Option<AhoSegmentedStrIter<'o, 'tb>>,
+    aho_iter: Option<AhoSegmentedStrIter<'o, 'aho>>,
     segmenter: &'static dyn Segmenter,
-    options: &'tb SegmenterOption<'tb>,
+    aho: Option<&'aho AhoCorasick>,
+    allow_list: Option<&'lang [Language]>,
     script: Script,
     language: Option<Language>,
 }
 
-impl<'o, 'tb> SegmentedStrIter<'o, 'tb> {
-    pub fn new(original: &'o str, options: &'tb SegmenterOption<'tb>) -> Self {
+impl<'o, 'aho, 'lang> SegmentedStrIter<'o, 'aho, 'lang> {
+    pub fn new(
+        original: &'o str,
+        aho: Option<&'aho AhoCorasick>,
+        allow_list: Option<&'lang [Language]>,
+    ) -> Self {
         let mut current_script = Script::Other;
         let mut group_id = 0;
         let inner = original.linear_group_by_key(move |c| {
@@ -149,14 +160,15 @@ impl<'o, 'tb> SegmentedStrIter<'o, 'tb> {
             current: Box::new(None.into_iter()),
             aho_iter: None,
             segmenter: &*DEFAULT_SEGMENTER,
-            options,
+            aho,
+            allow_list,
             script: Script::Other,
             language: None,
         }
     }
 }
 
-impl<'o, 'tb> Iterator for SegmentedStrIter<'o, 'tb> {
+impl<'o, 'aho, 'lang> Iterator for SegmentedStrIter<'o, 'aho, 'lang> {
     type Item = &'o str;
 
     fn next(&mut self) -> Option<Self::Item> {
@@ -171,13 +183,13 @@ impl<'o, 'tb> Iterator for SegmentedStrIter<'o, 'tb> {
                 }
                 None => {
                     let text = self.inner.next()?;
-                    let mut detector = text.detect(self.options.allow_list);
+                    let mut detector = text.detect(self.allow_list);
                     self.segmenter = segmenter(&mut detector);
                     self.script = detector.script();
                     self.language = detector.language;
                     self.aho_iter = Some(AhoSegmentedStrIter::new(
                         text,
-                        self.options.aho.as_ref().unwrap_or(&DEFAULT_SEPARATOR_AHO),
+                        self.aho.unwrap_or(&DEFAULT_SEPARATOR_AHO),
                     ));
 
                     self.next()
@@ -261,7 +273,7 @@ fn segmenter<'b>(detector: &mut StrDetection) -> &'b dyn Segmenter {
             let detected_language = detector.language();
             SEGMENTERS
                 .get(&(detected_script, detected_language))
-                .or_else(|| SEGMENTERS.get(&(detected_script, Language::Other)))
+                .or_else(|| SEGMENTERS.get(&(detected_script, None)))
                 .unwrap_or(&DEFAULT_SEGMENTER)
         }
     }
@@ -271,7 +283,7 @@ fn segmenter<'b>(detector: &mut StrDetection) -> &'b dyn Segmenter {
 #[derive(Debug, Clone, Default)]
 pub struct SegmenterOption<'tb> {
     pub aho: Option<AhoCorasick>,
-    pub allow_list: Option<&'tb HashMap<Script, Vec<Language>>>,
+    pub allow_list: Option<&'tb [Language]>,
 }
 
 /// Trait defining a segmenter.
@@ -319,16 +331,17 @@ pub trait Segment<'o> {
     /// assert_eq!(lemma, "quick");
     /// assert_eq!(kind, TokenKind::Unknown);
     /// ```
-    fn segment(&self) -> SegmentedTokenIter<'o, 'o> {
+    fn segment(&self) -> SegmentedTokenIter<'o, 'o, 'o> {
         self.segment_str().into()
     }
 
     /// Segments the provided text creating an Iterator over Tokens where you can specify an allowed list of languages to be used with a script.
-    fn segment_with_option<'tb>(
+    fn segment_with_option<'aho, 'lang>(
         &self,
-        options: &'tb SegmenterOption<'tb>,
-    ) -> SegmentedTokenIter<'o, 'tb> {
-        self.segment_str_with_option(options).into()
+        aho: Option<&'aho AhoCorasick>,
+        allow_list: Option<&'lang [Language]>,
+    ) -> SegmentedTokenIter<'o, 'aho, 'lang> {
+        self.segment_str_with_option(aho, allow_list).into()
     }
 
     /// Segments the provided text creating an Iterator over `&str`.
@@ -346,24 +359,26 @@ pub trait Segment<'o> {
     /// assert_eq!(segments.next(), Some(" "));
     /// assert_eq!(segments.next(), Some("quick"));
     /// ```
-    fn segment_str(&self) -> SegmentedStrIter<'o, 'o> {
-        self.segment_str_with_option(&SegmenterOption { aho: None, allow_list: None })
+    fn segment_str(&self) -> SegmentedStrIter<'o, 'o, 'o> {
+        self.segment_str_with_option(None, None)
     }
 
     /// Segments the provided text creating an Iterator over `&str` where you can specify an allowed list of languages to be used with a script.
     ///
-    fn segment_str_with_option<'tb>(
+    fn segment_str_with_option<'aho, 'lang>(
         &self,
-        options: &'tb SegmenterOption<'tb>,
-    ) -> SegmentedStrIter<'o, 'tb>;
+        aho: Option<&'aho AhoCorasick>,
+        allow_list: Option<&'lang [Language]>,
+    ) -> SegmentedStrIter<'o, 'aho, 'lang>;
 }
 
 impl<'o> Segment<'o> for &'o str {
-    fn segment_str_with_option<'tb>(
+    fn segment_str_with_option<'aho, 'lang>(
         &self,
-        options: &'tb SegmenterOption<'tb>,
-    ) -> SegmentedStrIter<'o, 'tb> {
-        SegmentedStrIter::new(self, options)
+        aho: Option<&'aho AhoCorasick>,
+        allow_list: Option<&'lang [Language]>,
+    ) -> SegmentedStrIter<'o, 'aho, 'lang> {
+        SegmentedStrIter::new(self, aho, allow_list)
     }
 }
 
diff --git a/charabia/src/tokenizer.rs b/charabia/src/tokenizer.rs
index e9b5f4dd..36b8443b 100644
--- a/charabia/src/tokenizer.rs
+++ b/charabia/src/tokenizer.rs
@@ -1,22 +1,21 @@
 use std::borrow::Cow;
-use std::collections::HashMap;
 
 use aho_corasick::{AhoCorasick, MatchKind};
 use fst::Set;
 
-use crate::detection::{Language, Script};
+use crate::detection::Language;
 use crate::normalizer::{NormalizedTokenIter, NormalizerOption};
 use crate::segmenter::{Segment, SegmentedStrIter, SegmentedTokenIter, SegmenterOption};
 use crate::separators::DEFAULT_SEPARATORS;
 use crate::Token;
 
 /// Iterator over tuples of [`&str`] (part of the original text) and [`Token`].
-pub struct ReconstructedTokenIter<'o, 'tb> {
-    token_iter: NormalizedTokenIter<'o, 'tb>,
+pub struct ReconstructedTokenIter<'o, 'aho, 'lang, 'tb> {
+    token_iter: NormalizedTokenIter<'o, 'aho, 'lang, 'tb>,
     original: &'o str,
 }
 
-impl<'o> Iterator for ReconstructedTokenIter<'o, '_> {
+impl<'o> Iterator for ReconstructedTokenIter<'o, '_, '_, '_> {
     type Item = (&'o str, Token<'o>);
 
     fn next(&mut self) -> Option<Self::Item> {
@@ -109,23 +108,55 @@ impl<'tb> Tokenizer<'tb> {
     ///
     /// The provided text is segmented creating tokens,
     /// then tokens are normalized and classified depending on the list of normalizers and classifiers in [`normalizer::NORMALIZERS`].
-    pub fn tokenize<'t, 'o>(&'t self, original: &'o str) -> NormalizedTokenIter<'o, 't> {
-        original.segment_with_option(&self.segmenter_option).normalize(&self.normalizer_option)
+    pub fn tokenize<'t, 'o>(&'t self, original: &'o str) -> NormalizedTokenIter<'o, 't, 't, 't> {
+        original
+            .segment_with_option(
+                self.segmenter_option.aho.as_ref(),
+                self.segmenter_option.allow_list,
+            )
+            .normalize(&self.normalizer_option)
+    }
+
+    /// Creates an Iterator over [`Token`]s.
+    ///
+    /// The provided text is segmented creating tokens,
+    /// then tokens are normalized and classified depending on the list of normalizers and classifiers in [`normalizer::NORMALIZERS`].
+    ///
+    /// # Arguments
+    ///
+    /// * `allow_list` - a slice of [`Language`] to allow during autodetection.
+    pub fn tokenize_with_allow_list<'t, 'o, 'lang>(
+        &'t self,
+        original: &'o str,
+        allow_list: Option<&'lang [Language]>,
+    ) -> NormalizedTokenIter<'o, 't, 'lang, 't> {
+        original
+            .segment_with_option(self.segmenter_option.aho.as_ref(), allow_list)
+            .normalize(&self.normalizer_option)
     }
 
     /// Same as [`tokenize`] but attaches each [`Token`] to its corresponding portion of the original text.
-    pub fn reconstruct<'t, 'o>(&'t self, original: &'o str) -> ReconstructedTokenIter<'o, 't> {
+    pub fn reconstruct<'t, 'o>(
+        &'t self,
+        original: &'o str,
+    ) -> ReconstructedTokenIter<'o, 't, 't, 't> {
         ReconstructedTokenIter { original, token_iter: self.tokenize(original) }
     }
 
     /// Segments the provided text creating an Iterator over [`Token`].
-    pub fn segment<'t, 'o>(&'t self, original: &'o str) -> SegmentedTokenIter<'o, 't> {
-        original.segment_with_option(&self.segmenter_option)
+    pub fn segment<'t, 'o>(&'t self, original: &'o str) -> SegmentedTokenIter<'o, 't, 't> {
+        original.segment_with_option(
+            self.segmenter_option.aho.as_ref(),
+            self.segmenter_option.allow_list,
+        )
     }
 
     /// Segments the provided text creating an Iterator over `&str`.
-    pub fn segment_str<'t, 'o>(&'t self, original: &'o str) -> SegmentedStrIter<'o, 't> {
-        original.segment_str_with_option(&self.segmenter_option)
+    pub fn segment_str<'t, 'o>(&'t self, original: &'o str) -> SegmentedStrIter<'o, 't, 't> {
+        original.segment_str_with_option(
+            self.segmenter_option.aho.as_ref(),
+            self.segmenter_option.allow_list,
+        )
     }
 }
 
@@ -301,7 +332,7 @@ impl<'tb, A: AsRef<[u8]>> TokenizerBuilder<'tb, A> {
     /// # Arguments
     ///
     /// * `allow_list` - a `HashMap` of the selection of languages associated with a script to limit during autodetection.
-    pub fn allow_list(&mut self, allow_list: &'tb HashMap<Script, Vec<Language>>) -> &mut Self {
+    pub fn allow_list(&mut self, allow_list: &'tb [Language]) -> &mut Self {
         self.segmenter_option.allow_list = Some(allow_list);
         self
     }