diff --git a/.cargo/config.toml b/.cargo/config.toml
new file mode 100644
index 00000000..9488ed84
--- /dev/null
+++ b/.cargo/config.toml
@@ -0,0 +1,3 @@
+# enables `cargo build -F python-bindings -v` on arm macs
+[target.aarch64-apple-darwin]
+rustflags = ["-C", "link-arg=-undefined", "-C", "link-arg=dynamic_lookup"]
diff --git a/python/outlines_core/fsm/guide.py b/python/outlines_core/fsm/guide.py
index b2de683a..dd116cd7 100644
--- a/python/outlines_core/fsm/guide.py
+++ b/python/outlines_core/fsm/guide.py
@@ -12,7 +12,6 @@
     Union,
 )
 
-import interegular
 import torch
 from outlines_core.fsm.regex import (
     create_fsm_index_tokenizer,
@@ -20,6 +19,8 @@
     make_deterministic_fsm,
 )
 
+import interegular
+
 if TYPE_CHECKING:
     from outlines_core.models.tokenizer import Tokenizer
 
diff --git a/python/outlines_core/fsm/outlines_core_rs.pyi b/python/outlines_core/fsm/outlines_core_rs.pyi
index f2fb3de2..ae614d46 100644
--- a/python/outlines_core/fsm/outlines_core_rs.pyi
+++ b/python/outlines_core/fsm/outlines_core_rs.pyi
@@ -1,4 +1,4 @@
-from typing import Dict, List, Optional, Set, Tuple
+from typing import Any, Dict, List, Optional, Set, Tuple
 
 class FSMInfo:
     initial: int
@@ -52,6 +52,8 @@ def create_fsm_index_end_to_end(
     vocabulary: Vocabulary,
     frozen_tokens: frozenset[str],
 ) -> Dict[int, Dict[int, int]]: ...
+def parse_pattern(pattern: str) -> Any: ...
+def parse_pattern_to_fsm(pattern: str) -> Any: ...
 
 BOOLEAN: str
 DATE: str
diff --git a/python/outlines_core/fsm/regex.py b/python/outlines_core/fsm/regex.py
index 13d72066..a412473a 100644
--- a/python/outlines_core/fsm/regex.py
+++ b/python/outlines_core/fsm/regex.py
@@ -23,13 +23,15 @@
     anything_else,
 )
 
-from .outlines_core_rs import (  # noqa: F401
+from .outlines_core_rs import (  # noqa: F401; TODO: likely temporary; just to ensure that the fsm creation works
     FSMInfo,
     Vocabulary,
     _walk_fsm,
     create_fsm_index_end_to_end,
     get_token_transition_keys,
     get_vocabulary_transition_keys,
+    parse_pattern,
+    parse_pattern_to_fsm,
     state_scan_tokens,
 )
 
diff --git a/src/interegular/fsm.rs b/src/interegular/fsm.rs
new file mode 100644
index 00000000..9876aaf7
--- /dev/null
+++ b/src/interegular/fsm.rs
@@ -0,0 +1,1041 @@
+use std::collections::{BTreeMap, BTreeSet, VecDeque};
+use std::fmt::Debug;
+use std::iter::from_fn;
+
+type TransitionKey = usize;
+// const ANYTHING_ELSE_KEY: TransitionKey = 500;
+const NONE_KEY: TransitionKey = 600;
+const ANYTHING_ELSE_CHAR: char = '\"';
+
+pub trait SymbolTrait: Eq + Clone + Debug + From<char> {}
+impl<T: Eq + Clone + Debug + From<char>> SymbolTrait for T {}
+
+#[derive(Debug, Clone, PartialEq)]
+pub struct Alphabet<T: SymbolTrait> {
+    pub symbol_mapping: BTreeMap<T, TransitionKey>,
+    pub by_transition: BTreeMap<TransitionKey, Vec<T>>,
+}
+
+impl<T: SymbolTrait + std::cmp::Ord> Alphabet<T> {
+    pub fn new(symbol_mapping: BTreeMap<T, TransitionKey>) -> Self {
+        let mut by_transition = BTreeMap::new();
+        for (symbol, transition) in &symbol_mapping {
+            by_transition
+                .entry(*transition)
+                .or_insert_with(Vec::new)
+                .push(symbol.clone());
+        }
+        Alphabet {
+            symbol_mapping,
+            by_transition,
+        }
+    }
+
+    #[must_use]
+    pub fn empty() -> Self {
+        Alphabet {
+            symbol_mapping: BTreeMap::new(),
+            by_transition: BTreeMap::new(),
+        }
+    }
+
+    pub fn get(&self, item: &T) -> TransitionKey {
+        match self.symbol_mapping.get(item) {
+            Some(x) => *x,
+            None => match self.symbol_mapping.get(&ANYTHING_ELSE_CHAR.into()) {
+                Some(x) => *x,
+                None => NONE_KEY,
+            },
+        }
+    }
+
+    pub fn contains(&self, item: &T) -> bool {
+        self.symbol_mapping.contains_key(item)
+    }
+
+    #[must_use]
+    pub fn from_groups(groups: &[BTreeSet<T>]) -> Self {
+        let mut symbol_mapping = BTreeMap::new();
+        for (i, group) in groups.iter().enumerate() {
+            for symbol in group {
+                symbol_mapping.insert(symbol.clone(), i);
+            }
+        }
+        Alphabet::new(symbol_mapping)
+    }
+
+    pub fn union(alphabets: &[Self]) -> (Self, Vec<BTreeMap<TransitionKey, TransitionKey>>) {
+        let all_symbols: BTreeSet<&T> = alphabets
+            .iter()
+            .flat_map(|a| a.symbol_mapping.keys())
+            .collect();
+        let mut symbol_to_keys = BTreeMap::new();
+        for symbol in all_symbols {
+            let keys = alphabets.iter().map(|a| a.get(symbol)).collect::<Vec<_>>();
+            symbol_to_keys.insert(symbol, keys);
+        }
+
+        let mut keys_to_symbols = BTreeMap::new(); // btree keeps the order
+        for (symbol, keys) in symbol_to_keys {
+            keys_to_symbols
+                .entry(keys.clone())
+                .or_insert_with(Vec::new)
+                .push(symbol);
+        }
+
+        let mut keys_to_key = BTreeMap::new();
+        for keys in keys_to_symbols.keys() {
+            keys_to_key.insert(keys.clone(), keys_to_key.len());
+        }
+
+        let mut symbol_mapping = BTreeMap::new();
+        for (keys, symbols) in keys_to_symbols {
+            for symbol in symbols {
+                symbol_mapping.insert(symbol.clone(), keys_to_key[&keys]);
+            }
+        }
+        let result = Alphabet::<T>::new(symbol_mapping);
+
+        let mut new_to_old_mappings: Vec<BTreeMap<TransitionKey, TransitionKey>> =
+            (0..alphabets.len()).map(|_| BTreeMap::new()).collect();
+
+        for (keys, new_key) in &keys_to_key {
+            for (i, &old_key) in keys.iter().enumerate() {
+                new_to_old_mappings[i].insert(*new_key, old_key);
+            }
+        }
+
+        (result, new_to_old_mappings)
+    }
+}
+
+impl Default for Alphabet<char> {
+    fn default() -> Self {
+        let mut symbol_mapping = BTreeMap::new();
+        // only insert \0 for anything_else
+        symbol_mapping.insert('\0', 0);
+        Alphabet::new(symbol_mapping)
+    }
+}
+
+#[derive(Debug, Clone, PartialEq)]
+pub struct Fsm<T: SymbolTrait> {
+    pub alphabet: Alphabet<T>,
+    pub states: BTreeSet<TransitionKey>,
+    pub initial: TransitionKey,
+    pub finals: BTreeSet<TransitionKey>,
+    pub map: BTreeMap<TransitionKey, BTreeMap<TransitionKey, TransitionKey>>,
+}
+impl<T: SymbolTrait + std::cmp::Ord> Fsm<T> {
+    #[must_use]
+    pub fn new(
+        alphabet: Alphabet<T>,
+        states: BTreeSet<TransitionKey>,
+        initial: TransitionKey,
+        finals: BTreeSet<TransitionKey>,
+        map: BTreeMap<TransitionKey, BTreeMap<TransitionKey, TransitionKey>>,
+    ) -> Self {
+        // TODO: revisit if we need validation logic
+        Fsm {
+            alphabet,
+            states,
+            initial,
+            finals,
+            map,
+        }
+    }
+
+    pub fn accepts(&self, input: &[T]) -> bool {
+        let mut state = self.initial;
+        for symbol in input.iter() {
+            let transition = self.alphabet.get(symbol);
+            let allowed_transition_map = self.map.get(&state);
+            match allowed_transition_map {
+                Some(transitions) => match transitions.get(&transition) {
+                    Some(next_state) => {
+                        state = *next_state;
+                    }
+                    None => {
+                        return false;
+                    }
+                },
+                None => {
+                    return false;
+                }
+            }
+        }
+        self.finals.contains(&state)
+    }
+
+    #[must_use]
+    pub fn reduce(&self) -> Self {
+        self.reversed().reversed()
+    }
+
+    pub fn reversed(&self) -> Self {
+        let initial = self.finals.clone();
+        let mut reverse_map = BTreeMap::new();
+
+        for (state, transition_map) in &self.map {
+            for (transition, next_state) in transition_map {
+                reverse_map
+                    .entry((*next_state, *transition))
+                    .or_insert_with(BTreeSet::new)
+                    .insert(*state);
+            }
+        }
+
+        let follow = |current: &BTreeSet<TransitionKey>,
+                      transition: &TransitionKey|
+         -> Option<BTreeSet<TransitionKey>> {
+            let mut next_states = BTreeSet::new();
+            for state in current {
+                if let Some(prev_states) = reverse_map.get(&(*state, *transition)) {
+                    next_states.extend(prev_states);
+                }
+            }
+            if next_states.is_empty() {
+                return None;
+            }
+            Some(next_states)
+        };
+
+        let final_fn = |state: &BTreeSet<TransitionKey>| state.contains(&self.initial);
+
+        crawl(&self.alphabet, initial, final_fn, follow)
+    }
+
+    #[must_use]
+    pub fn is_live(&self, state: TransitionKey) -> bool {
+        let mut seen = BTreeSet::new();
+        let mut reachable = vec![state];
+        let mut i = 0;
+
+        while i < reachable.len() {
+            let current = reachable[i];
+            if self.finals.contains(&current) {
+                return true;
+            }
+            if let Some(transitions) = self.map.get(&current) {
+                for next_state in transitions.values() {
+                    if !seen.contains(next_state) {
+                        reachable.push(*next_state);
+                        seen.insert(*next_state);
+                    }
+                }
+            }
+            i += 1;
+        }
+        false
+    }
+
+    #[must_use]
+    pub fn is_empty(&self) -> bool {
+        !self.is_live(self.initial)
+    }
+
+    pub fn strings(&self) -> impl Iterator<Item = Vec<T>> + '_ {
+        let live_states: BTreeSet<TransitionKey> = self
+            .states
+            .iter()
+            .filter(|&&s| self.is_live(s))
+            .copied()
+            .collect();
+        let mut strings = VecDeque::new();
+        let mut result = Vec::new();
+
+        if live_states.contains(&self.initial) {
+            if self.finals.contains(&self.initial) {
+                result.push(Vec::new());
+            }
+            strings.push_back((Vec::new(), self.initial));
+        }
+
+        from_fn(move || {
+            while let Some((current_string, current_state)) = strings.pop_front() {
+                if let Some(transitions) = self.map.get(&current_state) {
+                    for (transition, &next_state) in transitions {
+                        if live_states.contains(&next_state) {
+                            for symbol in &self.alphabet.by_transition[transition] {
+                                let mut new_string = current_string.clone();
+                                new_string.push(symbol.clone());
+                                if self.finals.contains(&next_state) {
+                                    result.push(new_string.clone());
+                                }
+                                strings.push_back((new_string, next_state));
+                            }
+                        }
+                    }
+                }
+            }
+            result.pop()
+        })
+    }
+
+    #[must_use]
+    pub fn union(fsms: &[Self]) -> Self {
+        Self::parallel(fsms, |accepts| accepts.iter().any(|&x| x))
+    }
+
+    #[must_use]
+    pub fn intersection(fsms: &[Self]) -> Self {
+        Self::parallel(fsms, |accepts| accepts.iter().all(|&x| x))
+    }
+
+    #[must_use]
+    pub fn symmetric_difference(fsms: &[Self]) -> Self {
+        Self::parallel(fsms, |accepts| {
+            accepts.iter().filter(|&&x| x).count() % 2 == 1
+        })
+    }
+
+    #[must_use]
+    pub fn difference(fsms: &[Self]) -> Self {
+        Self::parallel(fsms, |accepts| {
+            accepts[0] && !accepts[1..].iter().any(|&x| x)
+        })
+    }
+
+    #[must_use]
+    pub fn concatenate(fsms: &[Self]) -> Self {
+        let alphabets_from_fsms: Vec<Alphabet<T>> =
+            fsms.iter().map(|f| f.alphabet.clone()).collect();
+        let (alphabet, new_to_old) = Alphabet::union(alphabets_from_fsms.as_slice());
+        let last_index = fsms.len() - 1;
+        let last = &fsms[last_index];
+
+        let connect_all = |i: TransitionKey,
+                           substate: TransitionKey|
+         -> BTreeSet<(TransitionKey, TransitionKey)> {
+            let mut result = BTreeSet::new();
+            let current_i = i;
+            let mut current_substate = substate;
+
+            result.insert((i, substate));
+
+            let mut _current_i: usize = current_i;
+            while _current_i < last_index && fsms[_current_i].finals.contains(&current_substate) {
+                _current_i += 1;
+                current_substate = fsms[_current_i].initial;
+                result.insert((_current_i, current_substate));
+            }
+
+            result
+        };
+
+        let initial = connect_all(0, fsms[0].initial);
+
+        let final_fn = |state: &BTreeSet<(TransitionKey, TransitionKey)>| {
+            for &(i, substate) in state {
+                // if i == last_index && fsms[i].finals.contains(&substate) {
+                let _i: usize = i;
+                if _i == last_index && last.finals.contains(&substate) {
+                    return true;
+                }
+            }
+            false
+        };
+
+        let follow = |current: &BTreeSet<(TransitionKey, TransitionKey)>,
+                      transition: &TransitionKey|
+         -> Option<BTreeSet<(TransitionKey, TransitionKey)>> {
+            let mut next = BTreeSet::new();
+            for &(i, substate) in current {
+                let _i: usize = i;
+                let fsm = &fsms[_i];
+
+                if fsm.map.contains_key(&substate) {
+                    let a = new_to_old[_i].clone();
+                    let _b = a[transition];
+                    if fsm.map.contains_key(&substate) {
+                        // fsm.map[substate][new_to_old[i][new_transition]]
+                        let _i: usize = i;
+                        let key = &new_to_old[_i][transition];
+                        if let Some(&next_state) = fsm.map[&substate].get(key) {
+                            let connected = connect_all(i, next_state);
+                            next.extend(connected);
+                        }
+                    }
+                }
+            }
+            if next.is_empty() {
+                return None;
+            }
+            Some(next)
+        };
+
+        crawl(&alphabet, initial, final_fn, follow)
+    }
+
+    #[must_use]
+    pub fn star(&self) -> Self {
+        let initial = BTreeSet::from([self.initial]);
+
+        let follow = |state: &BTreeSet<TransitionKey>,
+                      transition: &TransitionKey|
+         -> Option<BTreeSet<TransitionKey>> {
+            let mut next = BTreeSet::new();
+            for &substate in state {
+                if let Some(transitions) = self.map.get(&substate) {
+                    if let Some(&next_state) = transitions.get(transition) {
+                        next.insert(next_state);
+                    }
+                }
+                if self.finals.contains(&substate) {
+                    if let Some(transitions) = self.map.get(&self.initial) {
+                        if let Some(&next_state) = transitions.get(transition) {
+                            next.insert(next_state);
+                        }
+                    }
+                }
+            }
+
+            if next.is_empty() {
+                return None;
+            }
+            Some(next)
+        };
+
+        let final_fn =
+            |state: &BTreeSet<TransitionKey>| state.iter().any(|s| self.finals.contains(s));
+
+        let mut result = crawl(&self.alphabet, initial, final_fn, follow);
+        result.finals.insert(result.initial);
+        result
+    }
+
+    #[must_use]
+    pub fn times(&self, multiplier: usize) -> Self {
+        // metastate is a set of iterations+states
+        let initial = BTreeSet::from([(self.initial, 0)]);
+        let final_fn = |state: &BTreeSet<(TransitionKey, usize)>| {
+            state.iter().any(|&(substate, iteration)| {
+                substate == self.initial
+                    && (self.finals.contains(&substate) || iteration == multiplier)
+            })
+        };
+
+        let follow = |current: &BTreeSet<(TransitionKey, usize)>,
+                      transition: &TransitionKey|
+         -> Option<BTreeSet<(TransitionKey, usize)>> {
+            let mut next = BTreeSet::new();
+
+            for &(substate, iteration) in current {
+                if iteration < multiplier
+                    && self.map.contains_key(&substate)
+                    && self.map[&substate].contains_key(transition)
+                {
+                    next.insert((self.map[&substate][transition], iteration));
+                    if self.finals.contains(&self.map[&substate][transition]) {
+                        next.insert((self.initial, iteration + 1));
+                    }
+                }
+            }
+            if next.is_empty() {
+                return None;
+            }
+            Some(next)
+        };
+
+        crawl(&self.alphabet, initial, final_fn, follow)
+    }
+
+    #[must_use]
+    pub fn everythingbut(&self) -> Self {
+        let initial = BTreeSet::from([(self.initial, 0)]);
+
+        let follow = |current: &BTreeSet<(TransitionKey, usize)>,
+                      transition: &TransitionKey|
+         -> Option<BTreeSet<(TransitionKey, usize)>> {
+            let mut next = BTreeSet::new();
+            for &(substate, iteration) in current {
+                if substate == self.initial
+                    && self.map.contains_key(&substate)
+                    && self.map[&substate].contains_key(transition)
+                {
+                    next.insert((self.map[&substate][transition], iteration));
+                }
+            }
+            if next.is_empty() {
+                return None;
+            }
+            Some(next)
+        };
+
+        let final_fn = |state: &BTreeSet<(TransitionKey, usize)>| {
+            !state.iter().any(|&(substate, _iteration)| {
+                substate == self.initial && self.finals.contains(&substate)
+            })
+        };
+
+        crawl(&self.alphabet, initial, final_fn, follow)
+    }
+
+    pub fn parallel<F>(fsms: &[Self], test: F) -> Self
+    where
+        F: Fn(&[bool]) -> bool,
+    {
+        let alphabets_from_fsms: Vec<Alphabet<T>> =
+            fsms.iter().map(|f| f.alphabet.clone()).collect();
+
+        let (alphabet, new_to_old) = Alphabet::union(alphabets_from_fsms.as_slice());
+        // let alphabet = alphabets.0;
+        // let new_to_old = alphabets.1;
+        let initial: BTreeMap<usize, TransitionKey> = fsms
+            .iter()
+            .enumerate()
+            .map(|(i, fsm)| (i, fsm.initial))
+            .collect();
+
+        let follow = |current: &BTreeSet<(usize, TransitionKey)>,
+                      transition: &TransitionKey|
+         -> Option<BTreeSet<(usize, TransitionKey)>> {
+            let mut next = BTreeSet::new();
+            for (i, fsm) in fsms.iter().enumerate() {
+                if let Some(old_transition) = new_to_old.get(i).and_then(|map| map.get(transition))
+                {
+                    if let Some((_, current_state)) = current.iter().find(|&&(idx, _)| idx == i) {
+                        if let Some(next_state) = fsm
+                            .map
+                            .get(current_state)
+                            .and_then(|map| map.get(old_transition))
+                        {
+                            next.insert((i, *next_state));
+                        }
+                    }
+                }
+            }
+            if next.is_empty() {
+                None
+            } else {
+                Some(next)
+            }
+        };
+
+        let final_fn = |state: &BTreeSet<(usize, TransitionKey)>| {
+            let accepts: Vec<bool> = fsms
+                .iter()
+                .enumerate()
+                .map(|(i, fsm)| {
+                    state
+                        .iter()
+                        .any(|&(idx, key)| idx == i && fsm.finals.contains(&key))
+                })
+                .collect();
+            test(&accepts)
+        };
+
+        let initial_set: BTreeSet<(usize, TransitionKey)> = initial.into_iter().collect();
+
+        crawl(&alphabet, initial_set, final_fn, follow)
+    }
+}
+
+#[must_use]
+pub fn null<T: SymbolTrait + std::cmp::Ord>(alphabet: &Alphabet<T>) -> Fsm<T> {
+    Fsm::new(
+        alphabet.clone(),
+        BTreeSet::from([0]),
+        0,
+        BTreeSet::new(),
+        BTreeMap::from([(0, alphabet.by_transition.keys().map(|&k| (k, 0)).collect())]),
+    )
+}
+
+#[must_use]
+pub fn epsilon<T: SymbolTrait + std::cmp::Ord>(alphabet: &Alphabet<T>) -> Fsm<T> {
+    Fsm::new(
+        alphabet.clone(),
+        BTreeSet::from([0]),
+        0,
+        BTreeSet::from([0]),
+        BTreeMap::new(),
+    )
+}
+
+fn crawl<T, F, G, I, C>(alphabet: &Alphabet<T>, initial: C, final_fn: F, follow: G) -> Fsm<T>
+where
+    T: SymbolTrait + std::cmp::Ord,
+    F: Fn(&C) -> bool,
+    G: Fn(&C, &TransitionKey) -> Option<C>,
+    I: Clone + Eq + std::fmt::Debug,
+    C: IntoIterator<Item = I> + FromIterator<I> + Clone + PartialEq + std::fmt::Debug,
+{
+    let mut states = VecDeque::new();
+    states.push_back(initial);
+    let mut finals = BTreeSet::<TransitionKey>::new();
+    let mut map = BTreeMap::new();
+    let mut i = 0;
+
+    while i < states.len() {
+        let state = states[i].clone();
+
+        if final_fn(&state) {
+            finals.insert(i);
+        }
+
+        map.insert(i, BTreeMap::new());
+
+        for transition in alphabet.by_transition.keys() {
+            match follow(&state, transition) {
+                Some(next) => {
+                    let j = if let Some(index) = states.iter().position(|s| s == &next) {
+                        index
+                    } else {
+                        states.push_back(next.clone());
+                        states.len() - 1
+                    };
+                    map.get_mut(&i).unwrap().insert(*transition, j);
+                }
+                None => {
+                    // reached oblivion
+                    continue;
+                }
+            }
+        }
+        i += 1;
+    }
+
+    Fsm::new(
+        alphabet.clone(),
+        (0..states.len()).collect(),
+        0,
+        finals,
+        map,
+    )
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_union_two_single_letter_alphabets() {
+        let mut symbol_mapping1 = BTreeMap::new();
+        symbol_mapping1.insert('\x00', 0);
+        symbol_mapping1.insert('a', 1);
+        let alphabet1 = Alphabet::new(symbol_mapping1);
+
+        let mut symbol_mapping2 = BTreeMap::new();
+        symbol_mapping2.insert('\x00', 0);
+        symbol_mapping2.insert('b', 1);
+        let alphabet2 = Alphabet::new(symbol_mapping2);
+
+        let (union_alphabet, new_to_old) = Alphabet::union(&[alphabet1.clone(), alphabet2.clone()]);
+
+        let expected_alphabet = Alphabet {
+            symbol_mapping: BTreeMap::from([('\x00', 0), ('a', 1), ('b', 2)]),
+            by_transition: BTreeMap::from([(0, vec!['\x00']), (1, vec!['a']), (2, vec!['b'])]),
+        };
+
+        println!("{:?}", union_alphabet);
+        println!("{:?}", new_to_old);
+
+        assert_eq!(union_alphabet, expected_alphabet);
+    }
+
+    #[test]
+    fn test_create_default_alphabet() {
+        let default_alphabet = Alphabet::<char>::default();
+        assert_eq!(default_alphabet.symbol_mapping.len(), 1);
+        assert_eq!(default_alphabet.by_transition.len(), 1);
+        assert_eq!(default_alphabet.by_transition[&0], vec!['\0']);
+    }
+
+    fn create_simple_fsm() -> Fsm<char> {
+        let mut symbol_mapping = BTreeMap::new();
+        symbol_mapping.insert('a', 0);
+        symbol_mapping.insert('b', 1);
+        let alphabet = Alphabet::new(symbol_mapping);
+
+        let mut map = BTreeMap::new();
+        // only 'a' transition from initial state
+        map.insert(0, [(0, 1)].iter().copied().collect());
+        // only 'b' transitions from accepting state
+        map.insert(1, [(1, 1)].iter().copied().collect());
+
+        Fsm::new(
+            alphabet,
+            [0, 1].iter().copied().collect(),
+            0,
+            [1].iter().copied().collect(),
+            map,
+        )
+    }
+
+    #[test]
+    fn test_simple_fsm() {
+        let fsm = create_simple_fsm();
+        assert!(fsm.accepts(&['a']));
+        assert!(fsm.accepts(&['a', 'b', 'b']));
+        assert!(fsm.accepts(&['a', 'b', 'b', 'b']));
+
+        assert!(!fsm.accepts(&['a', 'a', 'a']));
+        assert!(!fsm.accepts(&['b']));
+        assert!(!fsm.accepts(&['a', 'b', 'a', 'b', 'b']));
+    }
+
+    #[test]
+    fn test_is_empty() {
+        let fsm = create_simple_fsm();
+        assert!(!fsm.is_empty());
+
+        let empty_fsm = Fsm::new(
+            fsm.alphabet.clone(),
+            [0].iter().copied().collect(),
+            0,
+            BTreeSet::new(),
+            BTreeMap::new(),
+        );
+        assert!(empty_fsm.is_empty());
+    }
+
+    #[test]
+    fn test_reverse() {
+        let fsm = create_simple_fsm();
+        let reversed = fsm.reversed();
+
+        assert!(reversed.accepts(&['b', 'b', 'a']));
+        assert!(reversed.accepts(&['b', 'a']));
+
+        assert!(!reversed.accepts(&['a', 'a']));
+        // not accepted because it is not a final state
+        assert!(!reversed.accepts(&['b']));
+
+        // TODO: review this case
+        // its just the final state..
+        // not sure if we need to force it to be 'b' first?
+        assert!(reversed.accepts(&['a']));
+    }
+
+    #[test]
+    fn test_reduce() {
+        let fsm = create_simple_fsm();
+        let reduced = fsm.reduce();
+
+        // reduced FSM should have the same behavior as the original
+        assert!(fsm.accepts(&['a']));
+        assert!(fsm.accepts(&['a', 'b', 'b']));
+        assert!(fsm.accepts(&['a', 'b', 'b', 'b']));
+
+        assert!(!reduced.accepts(&['a', 'a', 'a']));
+        assert!(!reduced.accepts(&['b']));
+        assert!(!reduced.accepts(&['a', 'b', 'a', 'b', 'b']));
+    }
+
+    #[test]
+    fn test_union() {
+        let mut symbol_mapping = BTreeMap::new();
+        symbol_mapping.insert('a', 0);
+        symbol_mapping.insert('b', 1);
+        let alphabet = Alphabet::new(symbol_mapping);
+
+        let fsm1 = Fsm::new(
+            alphabet.clone(),
+            [0, 1].iter().copied().collect(),
+            0,
+            [1].iter().copied().collect(),
+            [(0, [(0, 1)].iter().copied().collect())]
+                .iter()
+                .cloned()
+                .collect(),
+        );
+
+        let fsm2 = Fsm::new(
+            alphabet.clone(),
+            [0, 1].iter().copied().collect(),
+            0,
+            [1].iter().copied().collect(),
+            [(0, [(1, 1)].iter().copied().collect())]
+                .iter()
+                .cloned()
+                .collect(),
+        );
+
+        let union = Fsm::union(&[fsm1, fsm2]);
+
+        assert!(union.accepts(&['a']));
+        assert!(union.accepts(&['b']));
+        assert!(!union.accepts(&['a', 'a']));
+    }
+
+    #[test]
+    fn test_union_of_single_character_fsms() {
+        // Create alphabet for FSM1 ('a' and anything_else)
+        let mut symbol_mapping1 = BTreeMap::new();
+        symbol_mapping1.insert('\0', 0); // '\0' represents anything_else
+        symbol_mapping1.insert('a', 1);
+        let alphabet1 = Alphabet::new(symbol_mapping1);
+
+        // Create alphabet for FSM2 ('b' and anything_else)
+        let mut symbol_mapping2 = BTreeMap::new();
+        symbol_mapping2.insert('\0', 0); // '\0' represents anything_else
+        symbol_mapping2.insert('b', 1);
+        let alphabet2 = Alphabet::new(symbol_mapping2);
+
+        let fsm1 = Fsm::new(
+            alphabet1.clone(),
+            [0, 1].iter().copied().collect(),
+            0,
+            [1].iter().copied().collect(),
+            [
+                //
+                (0, [(1, 1)].iter().copied().collect()),
+                (1, [].iter().copied().collect()),
+            ]
+            .iter()
+            .cloned()
+            .collect(),
+        );
+
+        let fsm2 = Fsm::new(
+            alphabet2.clone(),
+            [0, 1].iter().copied().collect(),
+            0,
+            [1].iter().copied().collect(),
+            [
+                (0, [(1, 1)].iter().copied().collect()),
+                (1, [].iter().copied().collect()),
+            ]
+            .iter()
+            .cloned()
+            .collect(),
+        );
+
+        assert_eq!(
+            fsm1.map,
+            [
+                (0, [(1, 1),].iter().copied().collect()),
+                (1, [].iter().copied().collect()),
+            ]
+            .iter()
+            .cloned()
+            .collect()
+        );
+
+        assert_eq!(
+            fsm2.map,
+            [
+                (0, [(1, 1),].iter().copied().collect()),
+                (1, [].iter().copied().collect()),
+            ]
+            .iter()
+            .cloned()
+            .collect()
+        );
+
+        let union_fsm = Fsm::union(&[fsm1, fsm2]);
+
+        assert_eq!(union_fsm.alphabet.symbol_mapping.len(), 3);
+        assert_eq!(union_fsm.states, [0, 1, 2].iter().copied().collect());
+        assert_eq!(union_fsm.initial, 0);
+        assert_eq!(union_fsm.finals, [2, 1].iter().copied().collect());
+
+        // compare states
+        assert_eq!(union_fsm.states, [0, 1, 2].iter().copied().collect());
+
+        let expected_map: BTreeMap<TransitionKey, BTreeMap<TransitionKey, TransitionKey>> = [
+            (0, [(1, 1), (2, 2)].iter().copied().collect()),
+            (1, [].iter().copied().collect()),
+            (2, [].iter().copied().collect()),
+        ]
+        .into();
+
+        assert_eq!(union_fsm.map.get(&2), Some(&expected_map[&2]));
+        assert_eq!(union_fsm.map.get(&1), Some(&expected_map[&1]));
+    }
+
+    #[test]
+    fn test_concatenate_of_single_character_fsms() {
+        // Create alphabet for FSM1 ('a' and anything_else)
+        let mut symbol_mapping1 = BTreeMap::new();
+        symbol_mapping1.insert('\0', 0); // '\0' represents anything_else
+        symbol_mapping1.insert('a', 1);
+        let alphabet1 = Alphabet::new(symbol_mapping1);
+
+        // Create alphabet for FSM2 ('b' and anything_else)
+        let mut symbol_mapping2 = BTreeMap::new();
+        symbol_mapping2.insert('\0', 0); // '\0' represents anything_else
+        symbol_mapping2.insert('b', 1);
+        let alphabet2 = Alphabet::new(symbol_mapping2);
+
+        // Create FSM for "a"
+        let fsm1 = Fsm::new(
+            alphabet1.clone(),
+            [0, 1].iter().copied().collect(),
+            0,
+            [1].iter().copied().collect(),
+            [
+                (0, [(1, 1)].iter().copied().collect()),
+                (1, [].iter().copied().collect()),
+            ]
+            .iter()
+            .cloned()
+            .collect(),
+        );
+
+        // Create FSM for "b"
+        let fsm2 = Fsm::new(
+            alphabet2.clone(),
+            [0, 1].iter().copied().collect(),
+            0,
+            [1].iter().copied().collect(),
+            [
+                (0, [(1, 1)].iter().copied().collect()),
+                (1, [].iter().copied().collect()),
+            ]
+            .iter()
+            .cloned()
+            .collect(),
+        );
+
+        let concat_fsm = Fsm::concatenate(&[fsm1, fsm2]);
+
+        let expected = Fsm {
+            alphabet: Alphabet {
+                symbol_mapping: BTreeMap::from([('\0', 0), ('a', 1), ('b', 2)]),
+                by_transition: BTreeMap::from([(0, vec!['\0']), (1, vec!['a']), (2, vec!['b'])]),
+            },
+            states: BTreeSet::from([0, 1, 2]),
+            initial: 0,
+            finals: BTreeSet::from([2]),
+            map: BTreeMap::from([
+                (0, BTreeMap::from([(1, 1)])),
+                (1, BTreeMap::from([(2, 2)])),
+                (2, BTreeMap::new()),
+            ]),
+        };
+
+        assert_eq!(concat_fsm.states, expected.states);
+        assert_eq!(concat_fsm.initial, expected.initial);
+        assert_eq!(concat_fsm.finals, expected.finals);
+
+        println!("{:?}", concat_fsm.alphabet);
+        println!("{:?}", concat_fsm.map);
+
+        assert_eq!(concat_fsm.map.get(&2), expected.map.get(&2));
+        assert_eq!(concat_fsm.map.get(&1), expected.map.get(&1));
+    }
+
+    #[test]
+    fn test_intersection() {
+        let fsm1 = Fsm::new(
+            create_simple_fsm().alphabet.clone(),
+            [0, 1].iter().copied().collect(),
+            0,
+            [1].iter().copied().collect(),
+            [(0, [(0, 1)].iter().copied().collect())]
+                .iter()
+                .cloned()
+                .collect(),
+        );
+
+        let fsm2 = Fsm::new(
+            create_simple_fsm().alphabet.clone(),
+            [0, 1].iter().copied().collect(),
+            0,
+            [1].iter().copied().collect(),
+            [(0, [(1, 1)].iter().copied().collect())]
+                .iter()
+                .cloned()
+                .collect(),
+        );
+
+        let intersection = Fsm::intersection(&[fsm1, fsm2]);
+
+        assert!(!intersection.accepts(&['a']));
+        assert!(!intersection.accepts(&['b']));
+        assert!(!intersection.accepts(&[' ']));
+        assert!(!intersection.accepts(&['a', 'a']));
+    }
+
+    #[test]
+    fn test_concatenate() {
+        let fsm1 = Fsm::new(
+            create_simple_fsm().alphabet.clone(),
+            [0, 1].iter().copied().collect(),
+            0,
+            [1].iter().copied().collect(),
+            [(0, [(0, 1)].iter().copied().collect())]
+                .iter()
+                .cloned()
+                .collect(),
+        );
+
+        let fsm2 = Fsm::new(
+            create_simple_fsm().alphabet.clone(),
+            [0, 1].iter().copied().collect(),
+            0,
+            [1].iter().copied().collect(),
+            [(0, [(1, 1)].iter().copied().collect())]
+                .iter()
+                .cloned()
+                .collect(),
+        );
+
+        let concatenated = Fsm::concatenate(&[fsm1, fsm2]);
+
+        // assert!(concatenated.accepts(&['a', 'b']));
+        assert!(!concatenated.accepts(&['a']));
+        assert!(!concatenated.accepts(&['b']));
+        assert!(!concatenated.accepts(&['b', 'a']));
+    }
+
+    #[test]
+    fn test_star() {
+        let fsm = Fsm::new(
+            create_simple_fsm().alphabet.clone(),
+            [0, 1].iter().copied().collect(),
+            0,
+            [1].iter().copied().collect(),
+            [(0, [(0, 1)].iter().copied().collect())]
+                .iter()
+                .cloned()
+                .collect(),
+        );
+
+        let star = fsm.star();
+
+        assert!(star.accepts(&[]));
+        assert!(star.accepts(&['a']));
+        assert!(star.accepts(&['a', 'a']));
+        assert!(star.accepts(&['a', 'a', 'a']));
+        assert!(!star.accepts(&['b']));
+    }
+
+    #[test]
+    fn test_times() {
+        let mut symbol_mapping = BTreeMap::new();
+        symbol_mapping.insert('a', 0);
+        symbol_mapping.insert('b', 1);
+        let alphabet = Alphabet::new(symbol_mapping);
+
+        let fsm = Fsm::new(
+            alphabet,
+            [0, 1].iter().copied().collect(),
+            0,
+            [1].iter().copied().collect(),
+            [
+                (0, [(0, 1)].iter().copied().collect()),
+                (1, [].iter().copied().collect()),
+            ]
+            .iter()
+            .cloned()
+            .collect(),
+        );
+
+        let times_2 = fsm.times(2);
+
+        assert!(times_2.accepts(&['a', 'a']));
+
+        assert!(!times_2.accepts(&[]));
+        assert!(!times_2.accepts(&['a']));
+        assert!(!times_2.accepts(&['a', 'a', 'a']));
+
+        assert!(!times_2.accepts(&['b']));
+        assert!(!times_2.accepts(&['a', 'b']));
+        assert!(!times_2.accepts(&['b', 'a']));
+        assert!(!times_2.accepts(&['b', 'b']));
+        assert!(!times_2.accepts(&['a', 'a', 'a', 'a', 'a']));
+    }
+}
diff --git a/src/interegular/mod.rs b/src/interegular/mod.rs
new file mode 100644
index 00000000..dc210a96
--- /dev/null
+++ b/src/interegular/mod.rs
@@ -0,0 +1,3 @@
+pub mod fsm;
+pub mod patterns;
+pub mod simple_parser;
diff --git a/src/interegular/patterns.rs b/src/interegular/patterns.rs
new file mode 100644
index 00000000..686581ed
--- /dev/null
+++ b/src/interegular/patterns.rs
@@ -0,0 +1,2288 @@
+#![allow(dead_code, unused_imports, unused_variables)]
+
+use std::collections::{BTreeMap, BTreeSet};
+use std::rc::Rc;
+use std::vec;
+
+use crate::interegular::fsm::SymbolTrait;
+use crate::interegular::fsm::{Alphabet, Fsm};
+use crate::interegular::simple_parser::NoMatch;
+
+const SPECIAL_CHARS_INNER: [&str; 2] = ["\\", "]"];
+const SPECIAL_CHARS_STANDARD: [&str; 11] = ["+", "?", "*", ".", "$", "^", "\\", "(", ")", "[", "|"];
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum RegexElement {
+    Literal(char),
+    CharGroup {
+        chars: BTreeSet<char>,
+        inverted: bool,
+    },
+    Repeated {
+        element: Box<RegexElement>,
+        min: usize,
+        max: Option<usize>,
+    },
+    Concatenation(Vec<RegexElement>),
+    Alternation(Vec<RegexElement>),
+    Capture(Box<RegexElement>),
+    Group(Box<RegexElement>),
+    Anchor(AnchorType),
+    Flag {
+        element: Box<RegexElement>,
+        added: Vec<Flag>,
+        removed: Vec<Flag>,
+    },
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub enum AnchorType {
+    StartOfLine,
+    EndOfLine,
+    WordBoundary,
+    NotWordBoundary,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub enum Flag {
+    CaseInsensitive,
+    Multiline,
+    DotMatchesNewline,
+    Unicode,
+}
+
+impl From<usize> for Flag {
+    fn from(value: usize) -> Self {
+        match value {
+            0 => Flag::CaseInsensitive,
+            1 => Flag::Multiline,
+            2 => Flag::DotMatchesNewline,
+            3 => Flag::Unicode,
+            _ => panic!("Invalid flag value"),
+        }
+    }
+}
+
+fn is_alphabetic(c: String) -> bool {
+    c.chars().next().unwrap().is_alphabetic()
+}
+
+fn _combine_char_groups(groups: &[RegexElement], negate: bool) -> RegexElement {
+    let mut pos = BTreeSet::new();
+    let mut neg = BTreeSet::new();
+
+    for group in groups {
+        match group {
+            RegexElement::CharGroup { chars, inverted } => {
+                if *inverted {
+                    neg.extend(chars.iter().copied());
+                } else {
+                    pos.extend(chars.iter().copied());
+                }
+            }
+            _ => panic!("Invalid group type"),
+        }
+    }
+
+    if !neg.is_empty() {
+        RegexElement::CharGroup {
+            chars: neg.difference(&pos).copied().collect(),
+            inverted: !negate,
+        }
+    } else {
+        RegexElement::CharGroup {
+            chars: pos.difference(&neg).copied().collect(),
+            inverted: negate,
+        }
+    }
+}
+
+impl RegexElement {
+    #[must_use]
+    pub fn repeat(self, min: usize, max: Option<usize>) -> Self {
+        RegexElement::Repeated {
+            element: Box::new(self),
+            min,
+            max,
+        }
+    }
+
+    #[must_use]
+    pub fn capture(self) -> Self {
+        RegexElement::Capture(Box::new(self))
+    }
+
+    #[must_use]
+    pub fn group(self) -> Self {
+        RegexElement::Group(Box::new(self))
+    }
+
+    #[must_use]
+    pub fn with_flags(self, added: Vec<Flag>, removed: Vec<Flag>) -> Self {
+        RegexElement::Flag {
+            element: Box::new(self),
+            added,
+            removed,
+        }
+    }
+}
+
+impl RegexElement {
+    #[must_use]
+    pub fn to_fsm(
+        &self,
+        alphabet: Option<Alphabet<char>>,
+        prefix_postfix: Option<(usize, Option<usize>)>,
+        flags: Option<BTreeSet<Flag>>,
+    ) -> Fsm<char> {
+        match self {
+            RegexElement::Literal(c) => {
+                let alphabet = alphabet
+                    .unwrap_or_else(|| self.get_alphabet(&flags.clone().unwrap_or_default()));
+                let prefix_postfix = prefix_postfix.unwrap_or_else(|| self.get_prefix_postfix());
+
+                // let case_insensitive = flags
+                //     .clone()
+                //     .as_ref()
+                //     .map_or(false, |f| f.contains(&Flag::CaseInsensitive));
+                let case_insensitive = false;
+
+                let mut mapping = BTreeMap::<_, BTreeMap<_, _>>::new();
+                let symbol = alphabet.get(c);
+
+                let mut m = std::collections::BTreeMap::new();
+                m.insert(symbol, 1_usize);
+                mapping.insert(0_usize, m);
+
+                // states based on the symbols
+                let unique_symbols = alphabet
+                    .by_transition
+                    .keys()
+                    .copied()
+                    .collect::<BTreeSet<_>>();
+
+                let states = unique_symbols.iter().copied().collect();
+                let finals = (1..=1).collect();
+
+                Fsm::new(
+                    alphabet, states, // {0, 1}
+                    0, finals, // {1}
+                    mapping,
+                )
+            }
+            RegexElement::CharGroup { chars, inverted } => {
+                let alphabet = alphabet
+                    .unwrap_or_else(|| self.get_alphabet(&flags.clone().unwrap_or_default()));
+                let prefix_postfix = prefix_postfix.unwrap_or_else(|| self.get_prefix_postfix());
+
+                assert!(
+                    prefix_postfix == (0, Some(0)),
+                    "Cannot have prefix/postfix on CharGroup-level"
+                );
+
+                // let case_insensitive = flags
+                //     .clone()
+                //     .as_ref()
+                //     .map_or(false, |f| f.contains(&Flag::CaseInsensitive));
+                let case_insensitive = false;
+
+                let mut mapping = BTreeMap::<_, BTreeMap<_, _>>::new();
+
+                if *inverted {
+                    let chars = chars.clone();
+                    let alphabet = alphabet.clone();
+                    let alphabet_set = alphabet
+                        .clone()
+                        .by_transition
+                        .keys()
+                        .copied()
+                        .collect::<BTreeSet<_>>();
+
+                    let char_as_usize = chars.iter().map(|c| *c as usize).collect();
+                    let diff = alphabet_set
+                        .difference(&char_as_usize)
+                        .copied()
+                        .collect::<Vec<_>>();
+
+                    let mut m = std::collections::BTreeMap::new();
+                    for symbol in diff {
+                        m.insert(symbol, 1_usize);
+                    }
+                    mapping.insert(0_usize, m);
+                } else {
+                    let chars = chars.clone();
+                    for symbol in chars {
+                        let mut m = std::collections::BTreeMap::new();
+                        let symbol_value = alphabet.get(&symbol);
+                        m.insert(symbol_value, 1_usize);
+                        mapping.insert(0_usize, m);
+                    }
+                }
+
+                let states = (0..=1).collect();
+                let finals = (1..=1).collect();
+
+                Fsm::new(
+                    alphabet, states, // {0, 1}
+                    0, finals, // {1}
+                    mapping,
+                )
+            }
+            RegexElement::Repeated { element, min, max } => {
+                // # REF
+                // def to_fsm(self, alphabet=None, prefix_postfix=None, flags=REFlags(0)) -> FSM:
+                //     if alphabet is None:
+                //         alphabet = self.get_alphabet(flags)
+                //     if prefix_postfix is None:
+                //         prefix_postfix = self.prefix_postfix
+                //     if prefix_postfix != (0, 0):
+                //         raise ValueError("Can not have prefix/postfix on CharGroup-level")
+                //     print("alphabet", alphabet.__dict__)
+                //     unit = self.base.to_fsm(alphabet, (0, 0), flags=flags)
+                //     print("unit", unit.__dict__)
+                //     mandatory = unit * self.min
+                //     print("mandatory", mandatory.__dict__, self.min)
+                //     if self.max is None:
+                //         optional = unit.star()
+                //     else:
+                //         optional = unit.copy()
+                //         optional.__dict__['finals'] |= {optional.initial}
+                //         optional *= (self.max - self.min)
+                //     return mandatory + optional
+
+                let unit = element.to_fsm(alphabet.clone(), None, flags.clone());
+                let alphabet = alphabet
+                    .unwrap_or_else(|| self.get_alphabet(&flags.clone().unwrap_or_default()));
+
+                let base_fsm = element.to_fsm(Some(alphabet.clone()), None, flags.clone());
+                let mandatory = std::iter::repeat(base_fsm.clone()).take(*min).fold(
+                    Fsm::new(
+                        alphabet.clone(),
+                        BTreeSet::from([0]),
+                        0,
+                        BTreeSet::from([0]),
+                        std::collections::BTreeMap::from([(0, BTreeMap::new())]),
+                    ),
+                    |acc, f| Fsm::concatenate(&[acc, f]),
+                );
+
+                let optional = if max.is_none() {
+                    unit.star()
+                } else {
+                    let mut optional = unit.clone();
+                    optional.finals.insert(optional.initial);
+                    optional = std::iter::repeat(optional.clone())
+                        .take(max.unwrap() - min)
+                        .fold(
+                            Fsm::new(
+                                alphabet.clone(),
+                                BTreeSet::new(),
+                                0,
+                                BTreeSet::new(),
+                                std::collections::BTreeMap::new(),
+                            ),
+                            |acc, f| Fsm::concatenate(&[acc, f]),
+                        );
+
+                    optional
+                };
+
+                Fsm::concatenate(&[mandatory, optional])
+            }
+            RegexElement::Concatenation(parts) => {
+                let mut current = vec![];
+                for part in parts {
+                    current.push(part.to_fsm(alphabet.clone(), None, flags.clone()));
+                }
+
+                Fsm::concatenate(&current)
+            }
+            RegexElement::Alternation(options) => {
+                let mut current = vec![];
+                for option in options {
+                    current.push(option.to_fsm(alphabet.clone(), None, flags.clone()));
+                }
+
+                Fsm::union(&current)
+            }
+            // throw on non implemented variants
+            _ => unimplemented!("FSM conversion not implemented for this variant"),
+        }
+    }
+
+    pub fn get_alphabet<T: SymbolTrait + std::cmp::Ord>(
+        &self,
+        flags: &BTreeSet<Flag>,
+    ) -> Alphabet<T> {
+        match self {
+            RegexElement::CharGroup { chars, .. } => {
+                // let case_insensitive = flags.contains(&Flag::CaseInsensitive);
+                let case_insensitive = false;
+                let relevant = if case_insensitive {
+                    chars
+                        .iter()
+                        // .flat_map(|c| vec![c.to_ascii_lowercase(), c.to_ascii_uppercase()])
+                        .flat_map(|c| vec![])
+                        .collect()
+                } else {
+                    chars.iter().map(|c| (*c).into()).collect()
+                };
+                // Alphabet::from_groups(&[relevant, BTreeSet::from([TransitionKey::AnythingElse])])
+                Alphabet::from_groups(&[relevant, BTreeSet::from(['\0'.into()])])
+            }
+            RegexElement::Literal(c) => Alphabet::from_groups(&[BTreeSet::from([(*c).into()])]),
+            RegexElement::Repeated { element, .. } => element.get_alphabet(flags),
+            RegexElement::Alternation(options) => {
+                let mut alphabet = Alphabet::empty();
+                for option in options {
+                    let alphabets = vec![alphabet, option.get_alphabet(flags)];
+                    let (res, new_to_old) = Alphabet::union(alphabets.as_slice());
+                    alphabet = res;
+                }
+                alphabet
+            }
+            RegexElement::Concatenation(parts) => {
+                let mut alphabet = Alphabet::empty();
+                for part in parts {
+                    let alphabets = vec![alphabet, part.get_alphabet(flags)];
+                    let (res, new_to_old) = Alphabet::union(alphabets.as_slice());
+                    alphabet = res;
+                }
+                alphabet
+            }
+            _ => unimplemented!("Alphabet not implemented for this variant"),
+        }
+    }
+
+    #[must_use]
+    pub fn get_prefix_postfix(&self) -> (usize, Option<usize>) {
+        match self {
+            RegexElement::CharGroup { .. } => (0, Some(0)),
+            RegexElement::Literal(_) => (1, Some(1)),
+            RegexElement::Repeated { element, min, max } => {
+                let (l, h) = element.get_prefix_postfix();
+                (l * min, max.and_then(|max| h.map(|h| h * max)))
+            }
+            RegexElement::Concatenation(parts) => {
+                let mut pre = 0;
+                let mut post = Some(0);
+
+                for part in parts {
+                    let (o_pre, o_post) = part.get_prefix_postfix();
+                    pre = pre.max(o_pre);
+                    post = match (post, o_post) {
+                        (Some(p), Some(o)) => Some(p.max(o)),
+                        (None, o) => o,
+                        (p, None) => p,
+                    };
+                }
+
+                (pre, post)
+            }
+            RegexElement::Alternation(options) => {
+                let mut pre = 0;
+                let mut post = Some(0);
+
+                for option in options {
+                    let (o_pre, o_post) = option.get_prefix_postfix();
+                    pre = pre.max(o_pre);
+                    post = match (post, o_post) {
+                        (Some(p), Some(o)) => Some(p.max(o)),
+                        (None, o) => o,
+                        (p, None) => p,
+                    };
+                }
+
+                (pre, post)
+            }
+            RegexElement::Capture(inner) => inner.get_prefix_postfix(),
+            RegexElement::Group(inner) => inner.get_prefix_postfix(),
+            RegexElement::Anchor(_) => (0, Some(0)),
+            RegexElement::Flag { element, .. } => element.get_prefix_postfix(),
+        }
+    }
+
+    #[must_use]
+    pub fn get_lengths(&self) -> (usize, Option<usize>) {
+        match self {
+            RegexElement::CharGroup { .. } => (1, Some(1)),
+            RegexElement::Literal(_) => (1, Some(1)),
+            RegexElement::Repeated { element, min, max } => {
+                let (l, h) = element.get_lengths();
+                (l * min, max.and_then(|max| h.map(|h| h * max)))
+            }
+            RegexElement::Concatenation(parts) => {
+                let mut low = 0;
+                let mut high = Some(0);
+
+                for part in parts {
+                    let (l, h) = part.get_lengths();
+                    low += l;
+                    high = high.and_then(|high| h.map(|h| high + h));
+                }
+
+                (low, high)
+            }
+            RegexElement::Alternation(options) => {
+                let mut low = None;
+                let mut high = Some(0);
+
+                for option in options {
+                    let (l, h) = option.get_lengths();
+                    low = Some(low.map_or(l, |low: usize| low.min(l)));
+                    high = match (high, h) {
+                        (Some(high), Some(h)) => Some(high.max(h)),
+                        _ => None,
+                    };
+                }
+
+                (low.unwrap_or(0), high)
+            }
+            RegexElement::Capture(inner) => inner.get_lengths(),
+            RegexElement::Group(inner) => inner.get_lengths(),
+            RegexElement::Anchor(_) => (0, Some(0)),
+            RegexElement::Flag { element, .. } => element.get_lengths(),
+        }
+    }
+
+    pub fn simplify(&self) -> RegexElement {
+        match self {
+            RegexElement::Alternation(options) => {
+                if options.len() == 1 {
+                    let o = &options[0];
+                    if let RegexElement::Concatenation(parts) = o {
+                        // must be len 1 and an alternation
+                        if parts.len() == 1 {
+                            if let RegexElement::Alternation(_options) = &parts[0] {
+                                return parts[0].simplify();
+                            }
+                        }
+                    }
+                }
+                let mut new_options = vec![];
+                for option in options {
+                    new_options.push(option.simplify());
+                }
+                RegexElement::Alternation(new_options)
+            }
+            RegexElement::Repeated { element, min, max } => RegexElement::Repeated {
+                element: Box::new(element.simplify()),
+                min: *min,
+                max: max.clone(),
+            },
+            RegexElement::Concatenation(parts) => {
+                let mut new_parts = vec![];
+                for part in parts {
+                    new_parts.push(part.simplify());
+                }
+                RegexElement::Concatenation(new_parts)
+            }
+            _ => self.clone(),
+        }
+    }
+
+    #[must_use]
+    pub fn to_concrete(&self) -> RegexElement {
+        self.clone()
+    }
+}
+
+pub struct ParsePattern<'a> {
+    parser: crate::interegular::simple_parser::SimpleParser<RegexElement>,
+    flags: Option<Vec<usize>>,
+    data: &'a str,
+}
+
+impl<'a> ParsePattern<'a> {
+    #[must_use]
+    pub fn new(data: &'a str) -> Self {
+        ParsePattern {
+            parser: crate::interegular::simple_parser::SimpleParser::new(data),
+            flags: None,
+            data,
+        }
+    }
+
+    pub fn parse(&mut self) -> Result<RegexElement, crate::interegular::simple_parser::NoMatch> {
+        let result = self.start()?;
+        if self.parser.index < self.data.len() {
+            let max_index = *self.parser.expected.keys().max().unwrap_or(&0);
+            Err(crate::interegular::simple_parser::NoMatch::new(
+                self.data,
+                max_index,
+                self.parser
+                    .expected
+                    .get(&max_index)
+                    .unwrap_or(&vec![])
+                    .clone(),
+            ))
+        } else {
+            Ok(result)
+        }
+    }
+
+    fn start(&mut self) -> Result<RegexElement, crate::interegular::simple_parser::NoMatch> {
+        self.flags = None;
+        let p = self.pattern()?;
+        if let Some(flags) = self.flags.take() {
+            Ok(p.with_flags(flags.iter().map(|f| Flag::from(*f)).collect(), vec![]))
+        } else {
+            Ok(p)
+        }
+    }
+
+    fn pattern(&mut self) -> Result<RegexElement, crate::interegular::simple_parser::NoMatch> {
+        let mut options = vec![self.conc()?];
+        while self.parser.static_b("|") {
+            options.push(self.conc()?);
+        }
+        Ok(RegexElement::Alternation(options))
+    }
+
+    fn conc(&mut self) -> Result<RegexElement, crate::interegular::simple_parser::NoMatch> {
+        let mut parts = vec![];
+        while let Ok(obj) = self.obj() {
+            parts.push(obj);
+        }
+        Ok(RegexElement::Concatenation(parts))
+    }
+
+    fn obj(&mut self) -> Result<RegexElement, crate::interegular::simple_parser::NoMatch> {
+        if self.parser.static_b("(") {
+            self.group()
+        } else {
+            match self.atom() {
+                Ok(atom) => self.repetition(atom),
+                Err(_) => Err(crate::interegular::simple_parser::NoMatch::new(
+                    self.data,
+                    self.parser.index,
+                    vec!["(".to_string()],
+                )),
+            }
+        }
+    }
+
+    fn atom(&mut self) -> Result<RegexElement, crate::interegular::simple_parser::NoMatch> {
+        if self.parser.static_b("[") {
+            match self.chargroup() {
+                Ok(cg) => self.repetition(cg),
+                Err(_) => Err(crate::interegular::simple_parser::NoMatch::new(
+                    self.data,
+                    self.parser.index,
+                    vec!["[".to_string()],
+                )),
+            }
+        } else if self.parser.static_b("\\") {
+            match self.escaped(false) {
+                Ok(cg) => self.repetition(cg),
+                Err(_) => Err(crate::interegular::simple_parser::NoMatch::new(
+                    self.data,
+                    self.parser.index,
+                    vec!["\\".to_string()],
+                )),
+            }
+        } else if self.parser.static_b(".") {
+            let cg = RegexElement::CharGroup {
+                chars: vec!['\n'].into_iter().collect(),
+                inverted: true,
+            };
+            self.repetition(cg)
+        } else if self.parser.static_b("$") {
+            // Unsupported
+            Err(crate::interegular::simple_parser::NoMatch::new(
+                self.data,
+                self.parser.index,
+                vec!["'$'".to_string()],
+            ))
+        } else if self.parser.static_b("^") {
+            // Unsupported
+            Err(crate::interegular::simple_parser::NoMatch::new(
+                self.data,
+                self.parser.index,
+                vec!["'^'".to_string()],
+            ))
+        } else {
+            let c = self.parser.any_but(&SPECIAL_CHARS_STANDARD, 1)?;
+            let cg = RegexElement::CharGroup {
+                chars: vec![c.chars().next().unwrap()].into_iter().collect(),
+                inverted: false,
+            };
+            self.repetition(cg)
+        }
+    }
+
+    fn group(&mut self) -> Result<RegexElement, crate::interegular::simple_parser::NoMatch> {
+        if self.parser.static_b("?") {
+            self.extension_group()
+        } else {
+            let p = self.pattern().unwrap();
+            self.parser.static_b(")");
+            self.repetition(p)
+        }
+    }
+
+    fn extension_group(
+        &mut self,
+    ) -> Result<RegexElement, crate::interegular::simple_parser::NoMatch> {
+        let c = self.parser.any(1)?;
+        if "aiLmsux-".contains(&c) {
+            self.parser.index -= 1;
+            let added_flags = self.parser.multiple("aiLmsux", 0, None)?;
+            let removed_flags = if self.parser.static_b("-") {
+                self.parser.multiple("aiLmsux", 1, None)?
+            } else {
+                String::new()
+            };
+
+            // TODO: missing cases
+        } else if c == ":" {
+            let p = self.pattern().unwrap();
+            self.parser.static_b(")");
+            return self.repetition(p);
+        }
+        unimplemented!("Missing cases")
+    }
+
+    fn repetition(
+        &mut self,
+        base: RegexElement,
+    ) -> Result<RegexElement, crate::interegular::simple_parser::NoMatch> {
+        if self.parser.static_b("*") {
+            self.parser.static_b("?");
+            Ok(RegexElement::Repeated {
+                element: Box::new(base),
+                min: 0,
+                max: None,
+            })
+        } else if self.parser.static_b("+") {
+            self.parser.static_b("?");
+            Ok(RegexElement::Repeated {
+                element: Box::new(base),
+                min: 1,
+                max: None,
+            })
+        } else if self.parser.static_b("?") {
+            self.parser.static_b("?");
+            Ok(RegexElement::Repeated {
+                element: Box::new(base),
+                min: 0,
+                max: Some(1),
+            })
+        } else if self.parser.static_b("{") {
+            let n = self.number().unwrap_or(0);
+            let m = if self.parser.static_b(",") {
+                match self.number() {
+                    Ok(num) => Some(num),
+                    Err(_) => None,
+                }
+            } else {
+                Some(n)
+            };
+            let _ = self.parser.static_match("}");
+            self.parser.static_b("?");
+            Ok(RegexElement::Repeated {
+                element: Box::new(base),
+                min: n,
+                max: m,
+            })
+        } else {
+            Ok(base)
+        }
+    }
+
+    fn number(&mut self) -> Result<usize, crate::interegular::simple_parser::NoMatch> {
+        let num = self.parser.multiple("0123456789", 1, None)?;
+        Ok(num.parse().unwrap())
+    }
+
+    fn chargroup(&mut self) -> Result<RegexElement, crate::interegular::simple_parser::NoMatch> {
+        let negate = self.parser.static_b("^");
+        let mut groups = vec![];
+        while let Ok(group) = self.chargroup_inner() {
+            groups.push(group);
+        }
+        let _ = self.parser.static_match("]");
+        if groups.len() == 1 {
+            let f = groups[0].clone();
+            match f {
+                RegexElement::CharGroup { chars, inverted } => Ok(RegexElement::CharGroup {
+                    chars,
+                    inverted: inverted ^ negate,
+                }),
+                _ => panic!("Invalid group type"),
+            }
+        } else if groups.is_empty() {
+            Ok(RegexElement::CharGroup {
+                chars: BTreeSet::new(),
+                inverted: negate,
+            })
+        } else {
+            Ok(_combine_char_groups(&groups, negate))
+        }
+    }
+
+    fn chargroup_inner(
+        &mut self,
+    ) -> Result<RegexElement, crate::interegular::simple_parser::NoMatch> {
+        let base = if self.parser.static_b("\\") {
+            self.escaped(true)
+        } else {
+            let c = self.parser.any_but(&SPECIAL_CHARS_INNER, 1)?;
+            Ok(RegexElement::CharGroup {
+                chars: vec![c.chars().next().unwrap()].into_iter().collect(),
+                inverted: false,
+            })
+        };
+        let base_copy = base.clone();
+        if self.parser.static_b("-") {
+            let end = if self.parser.static_b("\\") {
+                self.escaped(true)?
+            } else if self.parser.peek_static("]") {
+                // this case we have `X-]` which needs to include the `-` in
+                // the group since it's not a range
+                return Ok(_combine_char_groups(
+                    &[
+                        base_copy?,
+                        RegexElement::CharGroup {
+                            chars: vec!['-'].into_iter().collect(),
+                            inverted: false,
+                        },
+                    ],
+                    false,
+                ));
+            } else {
+                let c = self.parser.any_but(&SPECIAL_CHARS_INNER, 1)?;
+                RegexElement::CharGroup {
+                    chars: vec![c.chars().next().unwrap()].into_iter().collect(),
+                    inverted: false,
+                }
+            };
+
+            let low = match base? {
+                RegexElement::CharGroup { chars, .. } => *chars.iter().next().unwrap(),
+                _ => panic!("Invalid group type"),
+            };
+            let high = match end {
+                RegexElement::CharGroup { chars, .. } => *chars.iter().next().unwrap(),
+                _ => panic!("Invalid group type"),
+            };
+
+            assert!(low <= high, "Invalid Character-range");
+
+            let chars = (low..=high).collect();
+            return Ok(RegexElement::CharGroup {
+                chars,
+                inverted: false,
+            });
+        }
+
+        base
+    }
+
+    fn escaped(
+        &mut self,
+        inner: bool,
+    ) -> Result<RegexElement, crate::interegular::simple_parser::NoMatch> {
+        if self.parser.static_b("x") {
+            let n = self.parser.multiple("0123456789abcdefABCDEF", 2, Some(2))?;
+            let c = char::from_u32(u32::from_str_radix(&n, 16).unwrap()).unwrap();
+            return Ok(RegexElement::CharGroup {
+                chars: vec![c].into_iter().collect(),
+                inverted: false,
+            });
+        } else if self.parser.static_b("0") {
+            let n = self.parser.multiple("01234567", 1, Some(2))?;
+            let c = char::from_u32(u32::from_str_radix(&n, 8).unwrap()).unwrap();
+            return Ok(RegexElement::CharGroup {
+                chars: vec![c].into_iter().collect(),
+                inverted: false,
+            });
+        } else if self.parser.anyof_b(&["N", "p", "P", "u", "U"]) {
+            unimplemented!("regex module unicode properties are not supported.")
+        }
+
+        if !inner {
+            let n = self
+                .parser
+                .multiple("01234567", 3, Some(3))
+                .unwrap_or_default();
+            if !n.is_empty() {
+                let c = char::from_u32(u32::from_str_radix(&n, 8).unwrap()).unwrap();
+                return Ok(RegexElement::CharGroup {
+                    chars: vec![c].into_iter().collect(),
+                    inverted: false,
+                });
+            } else {
+                let n = self
+                    .parser
+                    .multiple("0123456789", 1, Some(2))
+                    .unwrap_or_default();
+                if !n.is_empty() {
+                    unimplemented!("Group references are not implemented")
+                } else {
+                    let n = self.parser.any_but(
+                        &[
+                            "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n",
+                            "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z", "A", "B",
+                            "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P",
+                            "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z",
+                        ],
+                        1,
+                    )?;
+                    let c = n.chars().next().unwrap();
+                    if c.is_alphabetic() {
+                        return Err(crate::interegular::simple_parser::NoMatch::new(
+                            self.data,
+                            self.parser.index,
+                            vec![n],
+                        ));
+                    } else {
+                        return Ok(RegexElement::CharGroup {
+                            chars: vec![c].into_iter().collect(),
+                            inverted: false,
+                        });
+                    }
+                }
+            }
+        }
+
+        // this is effectively the else branch of the if !inner check
+        let n = self.parser.multiple("01234567", 1, Some(3));
+        match n {
+            Ok(n) => {
+                let c = char::from_u32(u32::from_str_radix(&n, 8).unwrap()).unwrap();
+                Ok(RegexElement::CharGroup {
+                    chars: vec![c].into_iter().collect(),
+                    inverted: false,
+                })
+            }
+            Err(_) => {
+                let c = self.parser.anyof(&[
+                    "w", "W", "d", "D", "s", "S", "a", "b", "f", "n", "r", "t", "v",
+                ]);
+
+                match c {
+                    Ok(c) => {
+                        let chars = match c.as_str() {
+                            "w" => vec![
+                                'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
+                                'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
+                                'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
+                                'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
+                                '_', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
+                            ],
+                            "W" => vec!['\n', '\r', '\t', '\x0b', '\x0c', ' '],
+                            "d" => vec!['0', '1', '2', '3', '4', '5', '6', '7', '8', '9'],
+                            "D" => vec!['\n', '\r', '\t', '\x0b', '\x0c', ' '],
+                            "s" => vec!['\n', '\r', '\t', '\x0b', '\x0c', ' '],
+                            "S" => vec!['\n', '\r', '\t', '\x0b', '\x0c', ' '],
+                            "a" => vec!['\x07'],
+                            "b" => vec!['\x08'],
+                            "f" => vec!['\x0c'],
+                            "n" => vec!['\n'],
+                            "r" => vec!['\r'],
+                            "t" => vec!['\t'],
+                            "v" => vec!['\x0b'],
+                            _ => panic!("Invalid escape character"),
+                        };
+                        Ok(RegexElement::CharGroup {
+                            chars: chars.into_iter().collect(),
+                            inverted: false,
+                        })
+                    }
+                    Err(_) => {
+                        let c = self.parser.any_but(
+                            &[
+                                "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m",
+                                "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z",
+                                "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M",
+                                "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z",
+                            ],
+                            1,
+                        )?;
+                        if is_alphabetic(c.clone()) {
+                            Err(crate::interegular::simple_parser::NoMatch::new(
+                                self.data,
+                                self.parser.index,
+                                vec![c],
+                            ))
+                        } else {
+                            Ok(RegexElement::CharGroup {
+                                chars: c.chars().collect(),
+                                inverted: false,
+                            })
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
+pub fn parse_pattern(pattern: &str) -> Result<RegexElement, super::simple_parser::NoMatch> {
+    let mut parser = ParsePattern::new(pattern);
+    match parser.parse() {
+        Ok(raw_result) => Ok(raw_result.simplify()),
+        Err(e) => Err(e),
+    }
+}
+
+pub fn parse_pattern_to_fms(pattern: &str) -> Fsm<char> {
+    let regex_element = parse_pattern(pattern).unwrap();
+
+    let prefix_postfix = None;
+    let flags = None;
+
+    let default_alphabet = Alphabet::<char>::default();
+    let empty_flags: BTreeSet<Flag> = BTreeSet::new();
+    let patterns_alphabet: Alphabet<char> = regex_element.get_alphabet(&empty_flags);
+
+    let mut new_symbol_mapping: BTreeMap<char, usize> = BTreeMap::new();
+    let mut new_by_transition: BTreeMap<usize, Vec<char>> = BTreeMap::new();
+    new_symbol_mapping.insert('\0', 0);
+    for (symbol, index) in patterns_alphabet.symbol_mapping.iter() {
+        if *symbol != '\0' {
+            let new_index = index + 1;
+            new_symbol_mapping.insert(*symbol, new_index);
+            // add to the existing transitions if it exists
+            if new_by_transition.contains_key(&new_index) {
+                let transitions = new_by_transition.get_mut(&new_index).unwrap();
+                transitions.push(*symbol);
+            } else {
+                new_by_transition.insert(new_index, vec![*symbol]);
+            }
+        }
+    }
+    let alphabet = Alphabet {
+        symbol_mapping: new_symbol_mapping,
+        by_transition: new_by_transition,
+    };
+    let fsm_info = regex_element.to_fsm(Some(alphabet.clone()), prefix_postfix, flags);
+
+    fsm_info
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_parse_pattern_simple() {
+        let pattern: &str = "a";
+        let result = parse_pattern(pattern);
+        assert_eq!(
+            result,
+            Ok(RegexElement::Alternation(vec![
+                RegexElement::Concatenation(vec![RegexElement::CharGroup {
+                    chars: vec!['a'].into_iter().collect(),
+                    inverted: false
+                }])
+            ]))
+        );
+    }
+
+    #[test]
+    fn test_parse_pattern_alternation() {
+        let pattern = "a|b|c";
+        let result = parse_pattern(pattern);
+        assert_eq!(
+            result,
+            Ok(RegexElement::Alternation(vec![
+                RegexElement::Concatenation(vec![RegexElement::CharGroup {
+                    chars: vec!['a'].into_iter().collect(),
+                    inverted: false
+                }]),
+                RegexElement::Concatenation(vec![RegexElement::CharGroup {
+                    chars: vec!['b'].into_iter().collect(),
+                    inverted: false
+                }]),
+                RegexElement::Concatenation(vec![RegexElement::CharGroup {
+                    chars: vec!['c'].into_iter().collect(),
+                    inverted: false
+                }])
+            ]))
+        );
+    }
+
+    #[test]
+    fn test_parse_pattern_concatenation() {
+        let pattern = "abc";
+        let result = parse_pattern(pattern);
+        assert_eq!(
+            result,
+            Ok(RegexElement::Alternation(vec![
+                RegexElement::Concatenation(vec![
+                    RegexElement::CharGroup {
+                        chars: vec!['a'].into_iter().collect(),
+                        inverted: false
+                    },
+                    RegexElement::CharGroup {
+                        chars: vec!['b'].into_iter().collect(),
+                        inverted: false
+                    },
+                    RegexElement::CharGroup {
+                        chars: vec!['c'].into_iter().collect(),
+                        inverted: false
+                    }
+                ])
+            ]))
+        );
+    }
+
+    #[test]
+    fn test_parse_pattern_repetition() {
+        let pattern = "a*b+c?";
+        let result = parse_pattern(pattern);
+        assert_eq!(
+            result,
+            Ok(RegexElement::Alternation(vec![
+                RegexElement::Concatenation(vec![
+                    RegexElement::Repeated {
+                        element: Box::new(RegexElement::CharGroup {
+                            chars: vec!['a'].into_iter().collect(),
+                            inverted: false
+                        }),
+                        min: 0,
+                        max: None
+                    },
+                    RegexElement::Repeated {
+                        element: Box::new(RegexElement::CharGroup {
+                            chars: vec!['b'].into_iter().collect(),
+                            inverted: false
+                        }),
+                        min: 1,
+                        max: None
+                    },
+                    RegexElement::Repeated {
+                        element: Box::new(RegexElement::CharGroup {
+                            chars: vec!['c'].into_iter().collect(),
+                            inverted: false
+                        }),
+                        min: 0,
+                        max: Some(1)
+                    }
+                ])
+            ]))
+        );
+    }
+
+    #[test]
+    fn test_parse_pattern_chargroup() {
+        let pattern = "[abc]";
+        let result = parse_pattern(pattern);
+        assert_eq!(
+            result,
+            Ok(RegexElement::Alternation(vec![
+                RegexElement::Concatenation(vec![RegexElement::CharGroup {
+                    chars: vec!['a', 'b', 'c'].into_iter().collect(),
+                    inverted: false
+                }])
+            ]))
+        );
+    }
+
+    #[test]
+    fn test_parse_pattern_negated_chargroup() {
+        let pattern = "[^abc]";
+        let result = parse_pattern(pattern);
+        assert_eq!(
+            result,
+            Ok(RegexElement::Alternation(vec![
+                RegexElement::Concatenation(vec![RegexElement::CharGroup {
+                    chars: vec!['a', 'b', 'c'].into_iter().collect(),
+                    inverted: true
+                }])
+            ]))
+        );
+    }
+
+    #[test]
+    fn test_parse_pattern_escaped_chars() {
+        let pattern = r"\.\*\+\?\|\(\)\[\]\{\}\^\$";
+        let result = parse_pattern(pattern);
+        assert_eq!(
+            result,
+            Ok(RegexElement::Alternation(vec![
+                RegexElement::Concatenation(vec![
+                    RegexElement::CharGroup {
+                        chars: BTreeSet::from(['.']),
+                        inverted: false
+                    },
+                    RegexElement::CharGroup {
+                        chars: BTreeSet::from(['*']),
+                        inverted: false
+                    },
+                    RegexElement::CharGroup {
+                        chars: BTreeSet::from(['+']),
+                        inverted: false
+                    },
+                    RegexElement::CharGroup {
+                        chars: BTreeSet::from(['?']),
+                        inverted: false
+                    },
+                    RegexElement::CharGroup {
+                        chars: BTreeSet::from(['|']),
+                        inverted: false
+                    },
+                    RegexElement::CharGroup {
+                        chars: BTreeSet::from(['(']),
+                        inverted: false
+                    },
+                    RegexElement::CharGroup {
+                        chars: BTreeSet::from([')']),
+                        inverted: false
+                    },
+                    RegexElement::CharGroup {
+                        chars: BTreeSet::from(['[']),
+                        inverted: false
+                    },
+                    RegexElement::CharGroup {
+                        chars: BTreeSet::from([']']),
+                        inverted: false
+                    },
+                    RegexElement::CharGroup {
+                        chars: BTreeSet::from(['{']),
+                        inverted: false
+                    },
+                    RegexElement::CharGroup {
+                        chars: BTreeSet::from(['}']),
+                        inverted: false
+                    },
+                    RegexElement::CharGroup {
+                        chars: BTreeSet::from(['^']),
+                        inverted: false
+                    },
+                    RegexElement::CharGroup {
+                        chars: BTreeSet::from(['$']),
+                        inverted: false
+                    }
+                ]),
+            ]))
+        );
+    }
+
+    // #[test]
+    // fn test_parse_pattern_complex() {
+    //     let pattern = r"(a|b)*c+[def]\d{2,4}";
+    //     let result = parse_pattern(pattern);
+    //     assert_eq!(
+    //         result,
+    //         Ok(RegexElement::Alternation(vec![
+    //             RegexElement::Concatenation(vec![
+    //                 RegexElement::Repeated {
+    //                     element: Box::new(RegexElement::Group(Box::new(
+    //                         RegexElement::Alternation(vec![
+    //                             RegexElement::Concatenation(vec![RegexElement::Literal('a')]),
+    //                             RegexElement::Concatenation(vec![RegexElement::Literal('b')])
+    //                         ])
+    //                     ))),
+    //                     min: 0,
+    //                     max: None
+    //                 },
+    //                 RegexElement::Repeated {
+    //                     element: Box::new(RegexElement::Literal('c')),
+    //                     min: 1,
+    //                     max: None
+    //                 },
+    //                 RegexElement::CharGroup {
+    //                     chars: vec!['d', 'e', 'f'].into_iter().collect(),
+    //                     inverted: false
+    //                 },
+    //                 RegexElement::Repeated {
+    //                     element: Box::new(RegexElement::CharGroup {
+    //                         chars: ('0'..='9').collect(),
+    //                         inverted: false
+    //                     }),
+    //                     min: 2,
+    //                     max: Some(4)
+    //                 }
+    //             ])
+    //         ]))
+    //     );
+    // }
+
+    #[test]
+    fn test_parse_pattern_dot() {
+        let pattern = "a.b";
+        let result = parse_pattern(pattern);
+        assert_eq!(
+            result,
+            Ok(RegexElement::Alternation(vec![
+                RegexElement::Concatenation(vec![
+                    RegexElement::CharGroup {
+                        chars: vec!['a'].into_iter().collect(),
+                        inverted: false
+                    },
+                    RegexElement::CharGroup {
+                        chars: vec!['\n'].into_iter().collect(),
+                        inverted: true
+                    },
+                    RegexElement::CharGroup {
+                        chars: vec!['b'].into_iter().collect(),
+                        inverted: false
+                    }
+                ])
+            ]))
+        );
+    }
+
+    #[test]
+    fn test_parse_range() {
+        let pattern = "[a-f]";
+        let result = parse_pattern(pattern);
+        assert_eq!(
+            result,
+            Ok(RegexElement::Alternation(vec![
+                RegexElement::Concatenation(vec![RegexElement::CharGroup {
+                    chars: ('a'..='f').collect(),
+                    inverted: false
+                }])
+            ]))
+        );
+    }
+
+    #[test]
+    fn test_parse_pattern_repeat() {
+        let pattern = "a{3,6}";
+        let result = parse_pattern(pattern);
+        assert_eq!(
+            result,
+            Ok(RegexElement::Alternation(vec![
+                RegexElement::Concatenation(vec![RegexElement::Repeated {
+                    element: Box::new(RegexElement::CharGroup {
+                        chars: vec!['a'].into_iter().collect(),
+                        inverted: false
+                    }),
+                    min: 3,
+                    max: Some(6)
+                }])
+            ]))
+        );
+    }
+
+    #[test]
+    fn test_parse_pattern_anchors() {
+        let pattern = "abc$";
+        let result = parse_pattern(pattern);
+        assert_eq!(
+            result,
+            Ok(RegexElement::Alternation(vec![
+                RegexElement::Concatenation(vec![
+                    RegexElement::CharGroup {
+                        chars: BTreeSet::from(['a']),
+                        inverted: false
+                    },
+                    RegexElement::CharGroup {
+                        chars: BTreeSet::from(['b']),
+                        inverted: false
+                    },
+                    RegexElement::CharGroup {
+                        chars: BTreeSet::from(['c']),
+                        inverted: false
+                    },
+                ])
+            ]))
+        );
+    }
+
+    #[test]
+    fn test_parse_pattern_invalid() {
+        let pattern = ")(";
+        let result = parse_pattern(pattern);
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn test_parse_pattern_string_pattern() {
+        let pattern = "\"([^\"\\\\\\x00-\\x1F\\x7F-\\x9F]|\\\\[\"\\\\])*\"";
+        let result = parse_pattern(&pattern);
+        let ascii_chars: BTreeSet<u8> = (0x00..=0x1F).chain(0x7F..=0x9F).collect();
+        assert_eq!(
+            result,
+            Ok(RegexElement::Alternation(vec![
+                RegexElement::Concatenation(vec![
+                    RegexElement::CharGroup {
+                        chars: BTreeSet::from(['"',]),
+                        inverted: false,
+                    },
+                    RegexElement::Repeated {
+                        element: Box::new(RegexElement::Alternation(vec![
+                            RegexElement::Concatenation(vec![RegexElement::CharGroup {
+                                chars: BTreeSet::from([
+                                    '\0', '\u{1}', '\u{2}', '\u{3}', '\u{4}', '\u{5}', '\u{6}',
+                                    '\u{7}', '\u{8}', '\t', '\n', '\u{b}', '\u{c}', '\r', '\u{e}',
+                                    '\u{f}', '\u{10}', '\u{11}', '\u{12}', '\u{13}', '\u{14}',
+                                    '\u{15}', '\u{16}', '\u{17}', '\u{18}', '\u{19}', '\u{1a}',
+                                    '\u{1b}', '\u{1c}', '\u{1d}', '\u{1e}', '\u{1f}', '"', '\\',
+                                    '\u{7f}', '\u{80}', '\u{81}', '\u{82}', '\u{83}', '\u{84}',
+                                    '\u{85}', '\u{86}', '\u{87}', '\u{88}', '\u{89}', '\u{8a}',
+                                    '\u{8b}', '\u{8c}', '\u{8d}', '\u{8e}', '\u{8f}', '\u{90}',
+                                    '\u{91}', '\u{92}', '\u{93}', '\u{94}', '\u{95}', '\u{96}',
+                                    '\u{97}', '\u{98}', '\u{99}', '\u{9a}', '\u{9b}', '\u{9c}',
+                                    '\u{9d}', '\u{9e}', '\u{9f}',
+                                ]),
+                                inverted: true,
+                            },],),
+                            RegexElement::Concatenation(vec![
+                                RegexElement::CharGroup {
+                                    chars: BTreeSet::from(['\\',]),
+                                    inverted: false,
+                                },
+                                RegexElement::CharGroup {
+                                    chars: BTreeSet::from(['"', '\\',]),
+                                    inverted: false,
+                                },
+                            ],),
+                        ],)),
+                        min: 0,
+                        max: None,
+                    },
+                    RegexElement::CharGroup {
+                        chars: BTreeSet::from(['"',]),
+                        inverted: false,
+                    },
+                ],),
+            ]))
+        );
+    }
+
+    #[test]
+    fn test_parse_pattern_enum_string() {
+        let pattern = "(\"Marc\"|\"Jean\")";
+        let result = parse_pattern(pattern);
+        assert_eq!(
+            result,
+            Ok(RegexElement::Alternation(vec![
+                RegexElement::Concatenation(vec![
+                    RegexElement::CharGroup {
+                        chars: BTreeSet::from(['"']),
+                        inverted: false,
+                    },
+                    RegexElement::CharGroup {
+                        chars: BTreeSet::from(['M']),
+                        inverted: false,
+                    },
+                    RegexElement::CharGroup {
+                        chars: BTreeSet::from(['a']),
+                        inverted: false,
+                    },
+                    RegexElement::CharGroup {
+                        chars: BTreeSet::from(['r']),
+                        inverted: false,
+                    },
+                    RegexElement::CharGroup {
+                        chars: BTreeSet::from(['c']),
+                        inverted: false,
+                    },
+                    RegexElement::CharGroup {
+                        chars: BTreeSet::from(['"']),
+                        inverted: false,
+                    },
+                ]),
+                RegexElement::Concatenation(vec![
+                    RegexElement::CharGroup {
+                        chars: BTreeSet::from(['"']),
+                        inverted: false,
+                    },
+                    RegexElement::CharGroup {
+                        chars: BTreeSet::from(['J']),
+                        inverted: false,
+                    },
+                    RegexElement::CharGroup {
+                        chars: BTreeSet::from(['e']),
+                        inverted: false,
+                    },
+                    RegexElement::CharGroup {
+                        chars: BTreeSet::from(['a']),
+                        inverted: false,
+                    },
+                    RegexElement::CharGroup {
+                        chars: BTreeSet::from(['n']),
+                        inverted: false,
+                    },
+                    RegexElement::CharGroup {
+                        chars: BTreeSet::from(['"']),
+                        inverted: false,
+                    },
+                ]),
+            ]))
+        )
+    }
+
+    #[test]
+    fn test_parse_pattern_enum_char() {
+        let pattern = "(A|B)";
+        let result = parse_pattern(pattern);
+        assert_eq!(
+            result,
+            Ok(RegexElement::Alternation(vec![
+                RegexElement::Concatenation(vec![RegexElement::CharGroup {
+                    chars: BTreeSet::from(['A']),
+                    inverted: false
+                }]),
+                RegexElement::Concatenation(vec![RegexElement::CharGroup {
+                    chars: BTreeSet::from(['B']),
+                    inverted: false
+                }]),
+            ]))
+        )
+    }
+
+    #[test]
+    fn test_parse_pattern_null() {
+        let pattern = "null";
+        let result = parse_pattern(pattern);
+        assert_eq!(
+            result,
+            Ok(RegexElement::Alternation(vec![
+                RegexElement::Concatenation(vec![
+                    RegexElement::CharGroup {
+                        chars: BTreeSet::from(['n']),
+                        inverted: false
+                    },
+                    RegexElement::CharGroup {
+                        chars: BTreeSet::from(['u']),
+                        inverted: false
+                    },
+                    RegexElement::CharGroup {
+                        chars: BTreeSet::from(['l']),
+                        inverted: false
+                    },
+                    RegexElement::CharGroup {
+                        chars: BTreeSet::from(['l']),
+                        inverted: false
+                    },
+                ]),
+            ]))
+        )
+    }
+
+    #[test]
+    fn test_parse_pattern_number() {
+        let pattern = "((-)?(0|[1-9][0-9]*))(\\.[0-9]+)?([eE][+-][0-9]+)?";
+        let result = parse_pattern(pattern);
+        assert_eq!(
+            result,
+            Ok(RegexElement::Alternation(vec![
+                RegexElement::Concatenation(vec![
+                    RegexElement::Alternation(vec![RegexElement::Concatenation(vec![
+                        RegexElement::Repeated {
+                            element: Box::new(RegexElement::Alternation(vec![
+                                RegexElement::Concatenation(vec![RegexElement::CharGroup {
+                                    chars: BTreeSet::from(['-',]),
+                                    inverted: false,
+                                },]),
+                            ])),
+                            min: 0,
+                            max: Some(1),
+                        },
+                        RegexElement::Alternation(vec![
+                            RegexElement::Concatenation(vec![RegexElement::CharGroup {
+                                chars: BTreeSet::from(['0',]),
+                                inverted: false,
+                            }]),
+                            RegexElement::Concatenation(vec![
+                                RegexElement::CharGroup {
+                                    chars: BTreeSet::from([
+                                        '1', '2', '3', '4', '5', '6', '7', '8', '9',
+                                    ]),
+                                    inverted: false,
+                                },
+                                RegexElement::Repeated {
+                                    element: Box::new(RegexElement::CharGroup {
+                                        chars: BTreeSet::from([
+                                            '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
+                                        ]),
+                                        inverted: false,
+                                    }),
+                                    min: 0,
+                                    max: None,
+                                },
+                            ]),
+                        ]),
+                    ]),]),
+                    RegexElement::Repeated {
+                        element: Box::new(RegexElement::Alternation(vec![
+                            RegexElement::Concatenation(vec![
+                                RegexElement::CharGroup {
+                                    chars: BTreeSet::from(['.',]),
+                                    inverted: false,
+                                },
+                                RegexElement::Repeated {
+                                    element: Box::new(RegexElement::CharGroup {
+                                        chars: BTreeSet::from([
+                                            '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
+                                        ]),
+                                        inverted: false,
+                                    }),
+                                    min: 1,
+                                    max: None,
+                                },
+                            ]),
+                        ])),
+                        min: 0,
+                        max: Some(1),
+                    },
+                    RegexElement::Repeated {
+                        element: Box::new(RegexElement::Alternation(vec![
+                            RegexElement::Concatenation(vec![
+                                RegexElement::CharGroup {
+                                    chars: BTreeSet::from(['E', 'e',]),
+                                    inverted: false,
+                                },
+                                RegexElement::CharGroup {
+                                    chars: BTreeSet::from(['+', '-',]),
+                                    inverted: false,
+                                },
+                                RegexElement::Repeated {
+                                    element: Box::new(RegexElement::CharGroup {
+                                        chars: BTreeSet::from([
+                                            '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
+                                        ]),
+                                        inverted: false,
+                                    }),
+                                    min: 1,
+                                    max: None,
+                                },
+                            ]),
+                        ])),
+                        min: 0,
+                        max: Some(1),
+                    },
+                ]),
+            ]))
+        )
+    }
+
+    #[test]
+    fn test_parse_pattern_one_of_string_number_boolean() {
+        let pattern = "((?:\"([^\"\\\\\\x00-\\x1F\\x7F-\\x9F]|\\\\[\"\\\\])*\")|(?:((-)?(0|[1-9][0-9]*))(\\.[0-9]+)?([eE][+-][0-9]+)?)|(?:(true|false)))";
+        let result = parse_pattern(pattern);
+        println!("\n\n\n\ntest");
+        assert_eq!(
+            result,
+            Ok(RegexElement::Alternation(vec![
+                RegexElement::Concatenation(vec![RegexElement::Alternation(vec![
+                    RegexElement::Concatenation(vec![
+                        RegexElement::CharGroup {
+                            chars: BTreeSet::from(['"']),
+                            inverted: false,
+                        },
+                        RegexElement::Repeated {
+                            element: Box::new(RegexElement::Alternation(vec![
+                                RegexElement::Concatenation(vec![RegexElement::CharGroup {
+                                    chars: BTreeSet::from([
+                                        '\0', '\u{1}', '\u{2}', '\u{3}', '\u{4}', '\u{5}', '\u{6}',
+                                        '\u{7}', '\u{8}', '\t', '\n', '\u{b}', '\u{c}', '\r',
+                                        '\u{e}', '\u{f}', '\u{10}', '\u{11}', '\u{12}', '\u{13}',
+                                        '\u{14}', '\u{15}', '\u{16}', '\u{17}', '\u{18}', '\u{19}',
+                                        '\u{1a}', '\u{1b}', '\u{1c}', '\u{1d}', '\u{1e}', '\u{1f}',
+                                        '"', '\\', '\u{7f}', '\u{80}', '\u{81}', '\u{82}',
+                                        '\u{83}', '\u{84}', '\u{85}', '\u{86}', '\u{87}', '\u{88}',
+                                        '\u{89}', '\u{8a}', '\u{8b}', '\u{8c}', '\u{8d}', '\u{8e}',
+                                        '\u{8f}', '\u{90}', '\u{91}', '\u{92}', '\u{93}', '\u{94}',
+                                        '\u{95}', '\u{96}', '\u{97}', '\u{98}', '\u{99}', '\u{9a}',
+                                        '\u{9b}', '\u{9c}', '\u{9d}', '\u{9e}', '\u{9f}',
+                                    ]),
+                                    inverted: true,
+                                },]),
+                                RegexElement::Concatenation(vec![
+                                    RegexElement::CharGroup {
+                                        chars: BTreeSet::from(['\\']),
+                                        inverted: false
+                                    },
+                                    RegexElement::CharGroup {
+                                        chars: BTreeSet::from(['"', '\\']),
+                                        inverted: false
+                                    }
+                                ])
+                            ])),
+                            min: 0,
+                            max: None
+                        },
+                        RegexElement::CharGroup {
+                            chars: BTreeSet::from(['"']),
+                            inverted: false
+                        }
+                    ]),
+                ]),]),
+                RegexElement::Concatenation(vec![RegexElement::Alternation(vec![
+                    RegexElement::Concatenation(vec![
+                        RegexElement::Alternation(vec![RegexElement::Concatenation(vec![
+                            RegexElement::Repeated {
+                                element: Box::new(RegexElement::Alternation(vec![
+                                    RegexElement::Concatenation(vec![RegexElement::CharGroup {
+                                        chars: BTreeSet::from(['-',]),
+                                        inverted: false,
+                                    },]),
+                                ])),
+                                min: 0,
+                                max: Some(1),
+                            },
+                            RegexElement::Alternation(vec![
+                                RegexElement::Concatenation(vec![RegexElement::CharGroup {
+                                    chars: BTreeSet::from(['0']),
+                                    inverted: false,
+                                },]),
+                                RegexElement::Concatenation(vec![
+                                    RegexElement::CharGroup {
+                                        chars: BTreeSet::from([
+                                            '1', '2', '3', '4', '5', '6', '7', '8', '9',
+                                        ]),
+                                        inverted: false,
+                                    },
+                                    RegexElement::Repeated {
+                                        element: Box::new(RegexElement::CharGroup {
+                                            chars: BTreeSet::from([
+                                                '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
+                                            ]),
+                                            inverted: false,
+                                        }),
+                                        min: 0,
+                                        max: None,
+                                    },
+                                ]),
+                            ]),
+                        ]),]),
+                        RegexElement::Repeated {
+                            element: Box::new(RegexElement::Alternation(vec![
+                                RegexElement::Concatenation(vec![
+                                    RegexElement::CharGroup {
+                                        chars: BTreeSet::from(['.']),
+                                        inverted: false,
+                                    },
+                                    RegexElement::Repeated {
+                                        element: Box::new(RegexElement::CharGroup {
+                                            chars: BTreeSet::from([
+                                                '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
+                                            ]),
+                                            inverted: false,
+                                        }),
+                                        min: 1,
+                                        max: None,
+                                    },
+                                ]),
+                            ])),
+                            min: 0,
+                            max: Some(1),
+                        },
+                        RegexElement::Repeated {
+                            element: Box::new(RegexElement::Alternation(vec![
+                                RegexElement::Concatenation(vec![
+                                    RegexElement::CharGroup {
+                                        chars: BTreeSet::from(['E', 'e']),
+                                        inverted: false,
+                                    },
+                                    RegexElement::CharGroup {
+                                        chars: BTreeSet::from(['+', '-']),
+                                        inverted: false,
+                                    },
+                                    RegexElement::Repeated {
+                                        element: Box::new(RegexElement::CharGroup {
+                                            chars: BTreeSet::from([
+                                                '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
+                                            ]),
+                                            inverted: false,
+                                        }),
+                                        min: 1,
+                                        max: None,
+                                    },
+                                ]),
+                            ])),
+                            min: 0,
+                            max: Some(1),
+                        },
+                    ]),
+                ])]),
+                RegexElement::Concatenation(vec![RegexElement::Alternation(vec![
+                    RegexElement::Concatenation(vec![
+                        RegexElement::CharGroup {
+                            chars: BTreeSet::from(['t']),
+                            inverted: false,
+                        },
+                        RegexElement::CharGroup {
+                            chars: BTreeSet::from(['r']),
+                            inverted: false,
+                        },
+                        RegexElement::CharGroup {
+                            chars: BTreeSet::from(['u']),
+                            inverted: false,
+                        },
+                        RegexElement::CharGroup {
+                            chars: BTreeSet::from(['e']),
+                            inverted: false,
+                        },
+                    ]),
+                    RegexElement::Concatenation(vec![
+                        RegexElement::CharGroup {
+                            chars: BTreeSet::from(['f']),
+                            inverted: false,
+                        },
+                        RegexElement::CharGroup {
+                            chars: BTreeSet::from(['a']),
+                            inverted: false,
+                        },
+                        RegexElement::CharGroup {
+                            chars: BTreeSet::from(['l']),
+                            inverted: false,
+                        },
+                        RegexElement::CharGroup {
+                            chars: BTreeSet::from(['s']),
+                            inverted: false,
+                        },
+                        RegexElement::CharGroup {
+                            chars: BTreeSet::from(['e']),
+                            inverted: false,
+                        },
+                    ]),
+                ])])
+            ]))
+        )
+    }
+
+    #[test]
+    fn test_parse_pattern_literal_digit() {
+        let pattern = "0";
+        let result = parse_pattern(pattern);
+        assert_eq!(
+            result,
+            Ok(RegexElement::Alternation(vec![
+                RegexElement::Concatenation(vec![RegexElement::CharGroup {
+                    chars: BTreeSet::from(['0']),
+                    inverted: false
+                }]),
+            ]))
+        )
+    }
+
+    #[test]
+    fn test_parse_pattern_simple_to_fsm() {
+        let pattern: &str = "a";
+        let result = parse_pattern(pattern).unwrap();
+
+        let alphabet = Alphabet {
+            symbol_mapping: BTreeMap::from([('a', 1), ('\0', 0)]),
+            by_transition: BTreeMap::from([(0, vec!['\0']), (1, vec!['a'])]),
+        };
+
+        let result = result.to_fsm(Some(alphabet.clone()), None, None);
+
+        let expected = Fsm {
+            alphabet,
+            states: BTreeSet::from([0, 1]),
+            initial: 0,
+            finals: BTreeSet::from([1]),
+            map: BTreeMap::from([(0, BTreeMap::from([(1, 1)])), (1, BTreeMap::new())]),
+        };
+
+        assert_eq!(
+            result
+                .alphabet
+                .symbol_mapping
+                .keys()
+                .copied()
+                .collect::<BTreeSet<_>>(),
+            expected
+                .alphabet
+                .symbol_mapping
+                .keys()
+                .copied()
+                .collect::<BTreeSet<_>>()
+        );
+
+        assert_eq!(
+            result
+                .alphabet
+                .by_transition
+                .keys()
+                .copied()
+                .collect::<BTreeSet<_>>(),
+            expected
+                .alphabet
+                .by_transition
+                .keys()
+                .copied()
+                .collect::<BTreeSet<_>>()
+        );
+
+        assert_eq!(
+            result.states.iter().copied().collect::<BTreeSet<_>>(),
+            expected.states.iter().copied().collect::<BTreeSet<_>>()
+        );
+
+        assert_eq!(result.initial, expected.initial);
+
+        assert_eq!(
+            result.finals.iter().copied().collect::<BTreeSet<_>>(),
+            expected.finals.iter().copied().collect::<BTreeSet<_>>()
+        );
+
+        assert_eq!(
+            result.map.keys().copied().collect::<BTreeSet<_>>(),
+            expected.map.keys().copied().collect::<BTreeSet<_>>()
+        );
+    }
+
+    #[test]
+    fn test_parse_pattern_two_chars_to_fsm() {
+        let pattern: &str = "ab";
+        let result = parse_pattern(pattern).unwrap();
+
+        let alphabet = Alphabet {
+            symbol_mapping: BTreeMap::from([('\0', 0), ('a', 1), ('b', 2)]),
+            by_transition: BTreeMap::from([(0, vec!['\0']), (1, vec!['a']), (2, vec!['b'])]),
+        };
+
+        let result = result.to_fsm(Some(alphabet.clone()), None, None);
+
+        let expected = Fsm {
+            alphabet,
+            states: BTreeSet::from([0, 1, 2]),
+            initial: 0,
+            finals: BTreeSet::from([2]),
+            map: BTreeMap::from([
+                (0, BTreeMap::from([(1, 1)])),
+                (1, BTreeMap::from([(2, 2)])),
+                (2, BTreeMap::new()),
+            ]),
+        };
+
+        assert_eq!(
+            result
+                .alphabet
+                .symbol_mapping
+                .keys()
+                .copied()
+                .collect::<BTreeSet<_>>(),
+            expected
+                .alphabet
+                .symbol_mapping
+                .keys()
+                .copied()
+                .collect::<BTreeSet<_>>()
+        );
+
+        assert_eq!(
+            result
+                .alphabet
+                .by_transition
+                .keys()
+                .copied()
+                .collect::<BTreeSet<_>>(),
+            expected
+                .alphabet
+                .by_transition
+                .keys()
+                .copied()
+                .collect::<BTreeSet<_>>()
+        );
+
+        assert_eq!(
+            result.states.iter().copied().collect::<BTreeSet<_>>(),
+            expected.states.iter().copied().collect::<BTreeSet<_>>()
+        );
+
+        assert_eq!(result.initial, expected.initial);
+
+        assert_eq!(
+            result.finals.iter().copied().collect::<BTreeSet<_>>(),
+            expected.finals.iter().copied().collect::<BTreeSet<_>>()
+        );
+
+        assert_eq!(
+            result.map.keys().copied().collect::<BTreeSet<_>>(),
+            expected.map.keys().copied().collect::<BTreeSet<_>>()
+        );
+    }
+
+    #[test]
+    fn test_parse_pattern_to_fms() {
+        let test_cases = vec![
+            (
+                "a",
+                Fsm {
+                    alphabet: Alphabet {
+                        symbol_mapping: BTreeMap::from([('\0', 0), ('a', 1)]),
+                        by_transition: BTreeMap::from([(0, vec!['\0']), (1, vec!['a'])]),
+                    },
+                    states: BTreeSet::from([0, 1]),
+                    initial: 0,
+                    finals: BTreeSet::from([1]),
+                    map: BTreeMap::from([(0, BTreeMap::from([(1, 1)])), (1, BTreeMap::new())]),
+                },
+            ),
+            (
+                "ab",
+                Fsm {
+                    alphabet: Alphabet {
+                        symbol_mapping: BTreeMap::from([('\0', 0), ('a', 1), ('b', 2)]),
+                        by_transition: BTreeMap::from([
+                            (0, vec!['\0']),
+                            (1, vec!['a']),
+                            (2, vec!['b']),
+                        ]),
+                    },
+                    states: BTreeSet::from([0, 1, 2]),
+                    initial: 0,
+                    finals: BTreeSet::from([2]),
+                    map: BTreeMap::from([
+                        (0, BTreeMap::from([(1, 1)])),
+                        (1, BTreeMap::from([(2, 2)])),
+                        (2, BTreeMap::new()),
+                    ]),
+                },
+            ),
+            (
+                "a|b",
+                Fsm {
+                    alphabet: Alphabet {
+                        symbol_mapping: BTreeMap::from([('\0', 0), ('a', 1), ('b', 2)]),
+                        by_transition: BTreeMap::from([
+                            (0, vec!['\0']),
+                            (1, vec!['a']),
+                            (2, vec!['b']),
+                        ]),
+                    },
+                    states: BTreeSet::from([0, 1, 2]),
+                    initial: 0,
+                    finals: BTreeSet::from([1, 2]),
+                    map: BTreeMap::from([
+                        (0, BTreeMap::from([(1, 1), (2, 2)])),
+                        (1, BTreeMap::new()),
+                        (2, BTreeMap::new()),
+                    ]),
+                },
+            ),
+            (
+                "[ab]",
+                Fsm {
+                    alphabet: Alphabet {
+                        symbol_mapping: BTreeMap::from([('\0', 0), ('a', 1), ('b', 1)]),
+                        by_transition: BTreeMap::from([(0, vec!['\0']), (1, vec!['a', 'b'])]),
+                    },
+                    states: BTreeSet::from([0, 1]),
+                    initial: 0,
+                    finals: BTreeSet::from([1]),
+                    map: BTreeMap::from([(0, BTreeMap::from([(1, 1)])), (1, BTreeMap::new())]),
+                },
+            ),
+            (
+                "aaaaa",
+                Fsm {
+                    alphabet: Alphabet {
+                        symbol_mapping: BTreeMap::from([('\0', 0), ('a', 1)]),
+                        by_transition: BTreeMap::from([(0, vec!['\0']), (1, vec!['a'])]),
+                    },
+                    states: BTreeSet::from([0, 1, 2, 3, 4, 5]),
+                    initial: 0,
+                    finals: BTreeSet::from([5]),
+                    map: BTreeMap::from([
+                        (0, BTreeMap::from([(1, 1)])),
+                        (1, BTreeMap::from([(1, 2)])),
+                        (2, BTreeMap::from([(1, 3)])),
+                        (3, BTreeMap::from([(1, 4)])),
+                        (4, BTreeMap::from([(1, 5)])),
+                        (5, BTreeMap::new()),
+                    ]),
+                },
+            ),
+            (
+                "davidholtz",
+                Fsm {
+                    alphabet: Alphabet {
+                        symbol_mapping: BTreeMap::from([
+                            ('\0', 0),
+                            ('a', 2),
+                            ('d', 1),
+                            ('h', 5),
+                            ('i', 4),
+                            ('l', 7),
+                            ('o', 6),
+                            ('t', 8),
+                            ('v', 3),
+                            ('z', 9),
+                        ]),
+                        by_transition: BTreeMap::from([
+                            (0, vec!['\0']),
+                            (2, vec!['a']),
+                            (1, vec!['d']),
+                            (5, vec!['h']),
+                            (4, vec!['i']),
+                            (7, vec!['l']),
+                            (6, vec!['o']),
+                            (8, vec!['t']),
+                            (3, vec!['v']),
+                            (9, vec!['z']),
+                        ]),
+                    },
+                    states: BTreeSet::from([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]),
+                    initial: 0,
+                    finals: BTreeSet::from([10]),
+                    map: BTreeMap::from([
+                        (0, BTreeMap::from([(1, 1)])),
+                        (1, BTreeMap::from([(2, 2)])),
+                        (2, BTreeMap::from([(3, 3)])),
+                        (3, BTreeMap::from([(4, 4)])),
+                        (4, BTreeMap::from([(1, 5)])),
+                        (5, BTreeMap::from([(5, 6)])),
+                        (6, BTreeMap::from([(6, 7)])),
+                        (7, BTreeMap::from([(7, 8)])),
+                        (8, BTreeMap::from([(8, 9)])),
+                        (9, BTreeMap::from([(9, 10)])),
+                        (10, BTreeMap::new()),
+                    ]),
+                },
+            ),
+            (
+                "a*b",
+                Fsm {
+                    alphabet: Alphabet {
+                        symbol_mapping: BTreeMap::from([('\0', 0), ('a', 1), ('b', 2)]),
+                        by_transition: BTreeMap::from([
+                            (0, vec!['\0']),
+                            (1, vec!['a']),
+                            (2, vec!['b']),
+                        ]),
+                    },
+                    states: BTreeSet::from([0, 1, 2]),
+                    initial: 0,
+                    finals: BTreeSet::from([2]),
+                    map: BTreeMap::from([
+                        (0, BTreeMap::from([(1, 1), (2, 2)])),
+                        (1, BTreeMap::from([(1, 1), (2, 2)])),
+                        (2, BTreeMap::new()),
+                    ]),
+                },
+            ),
+            (
+                "(ab|cd)*",
+                Fsm {
+                    alphabet: Alphabet {
+                        symbol_mapping: BTreeMap::from([
+                            ('\0', 0),
+                            ('a', 1),
+                            ('b', 2),
+                            ('c', 3),
+                            ('d', 4),
+                        ]),
+                        by_transition: BTreeMap::from([
+                            (0, vec!['\0']),
+                            (1, vec!['a']),
+                            (2, vec!['b']),
+                            (3, vec!['c']),
+                            (4, vec!['d']),
+                        ]),
+                    },
+                    states: BTreeSet::from([0, 1, 2, 3, 4]),
+                    initial: 0,
+                    finals: BTreeSet::from([0, 3, 4]),
+                    map: BTreeMap::from([
+                        (0, BTreeMap::from([(1, 1), (3, 2)])),
+                        (1, BTreeMap::from([(2, 3)])),
+                        (2, BTreeMap::from([(4, 4)])),
+                        (3, BTreeMap::from([(1, 1), (3, 2)])),
+                        (4, BTreeMap::from([(1, 1), (3, 2)])),
+                    ]),
+                },
+            ),
+            (
+                "[a-d]",
+                Fsm {
+                    alphabet: Alphabet {
+                        symbol_mapping: BTreeMap::from([
+                            ('\0', 0),
+                            ('a', 1),
+                            ('b', 1),
+                            ('c', 1),
+                            ('d', 1),
+                        ]),
+                        by_transition: BTreeMap::from([
+                            (0, vec!['\0']),
+                            (1, vec!['a', 'b', 'c', 'd']),
+                        ]),
+                    },
+                    states: BTreeSet::from([0, 1]),
+                    initial: 0,
+                    finals: BTreeSet::from([1]),
+                    map: BTreeMap::from([(0, BTreeMap::from([(1, 1)])), (1, BTreeMap::new())]),
+                },
+            ),
+            (
+                "[a-z0-9]+",
+                Fsm {
+                    alphabet: Alphabet {
+                        symbol_mapping: BTreeMap::from([
+                            ('\0', 0),
+                            ('0', 1),
+                            ('1', 1),
+                            ('2', 1),
+                            ('3', 1),
+                            ('4', 1),
+                            ('5', 1),
+                            ('6', 1),
+                            ('7', 1),
+                            ('8', 1),
+                            ('9', 1),
+                            ('a', 1),
+                            ('b', 1),
+                            ('c', 1),
+                            ('d', 1),
+                            ('e', 1),
+                            ('f', 1),
+                            ('g', 1),
+                            ('h', 1),
+                            ('i', 1),
+                            ('j', 1),
+                            ('k', 1),
+                            ('l', 1),
+                            ('m', 1),
+                            ('n', 1),
+                            ('o', 1),
+                            ('p', 1),
+                            ('q', 1),
+                            ('r', 1),
+                            ('s', 1),
+                            ('t', 1),
+                            ('u', 1),
+                            ('v', 1),
+                            ('w', 1),
+                            ('x', 1),
+                            ('y', 1),
+                            ('z', 1),
+                        ]),
+                        by_transition: BTreeMap::from([
+                            (0, vec!['\0']),
+                            (
+                                1,
+                                vec![
+                                    '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b',
+                                    'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n',
+                                    'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
+                                ],
+                            ),
+                        ]),
+                    },
+                    states: BTreeSet::from([0, 1, 2]),
+                    initial: 0,
+                    finals: BTreeSet::from([1, 2]),
+                    map: BTreeMap::from([
+                        (0, BTreeMap::from([(1, 1)])),
+                        (1, BTreeMap::from([(1, 2)])),
+                        (2, BTreeMap::from([(1, 2)])),
+                    ]),
+                },
+            ),
+            // (
+            //     "c?",
+            //     Fsm {
+            //         alphabet: Alphabet {
+            //             symbol_mapping: BTreeMap::from([('\0', 0), ('c', 1)]),
+            //             by_transition: BTreeMap::from([(0, vec!['\0']), (1, vec!['c'])]),
+            //         },
+            //         states: BTreeSet::from([0, 1]),
+            //         initial: 0,
+            //         finals: BTreeSet::from([1]),
+            //         map: BTreeMap::from([(0, BTreeMap::from([(1, 1)])), (1, BTreeMap::new())]),
+            //     },
+            // ),
+        ];
+
+        for (pattern, expected) in test_cases {
+            let fsm = parse_pattern_to_fms(pattern);
+
+            println!("\n\n\nPattern: {}", pattern);
+            println!("Generated FSM: {:?}", fsm);
+            println!("Expected  FSM: {:?}", expected);
+
+            for (state, transitions) in fsm.map.iter() {
+                for (symbol, next_state) in transitions.iter() {
+                    assert!(
+                        expected.map[state].contains_key(symbol),
+                        "State {} does not contain symbol {}",
+                        state,
+                        symbol
+                    );
+                    assert_eq!(
+                        expected.map[state][symbol], *next_state,
+                        "State {} does not transition to the expected state for symbol {}",
+                        state, symbol
+                    );
+                }
+            }
+            assert_eq!(fsm.states, expected.states);
+            assert_eq!(fsm.initial, expected.initial);
+            assert_eq!(fsm.finals, expected.finals);
+            assert_eq!(fsm.map, expected.map);
+        }
+    }
+
+    #[test]
+    fn test_simplify_pattern() {
+        let tree = RegexElement::Alternation(vec![RegexElement::Concatenation(vec![
+            RegexElement::CharGroup {
+                chars: BTreeSet::from(['a']),
+                inverted: false,
+            },
+            RegexElement::Alternation(vec![RegexElement::Concatenation(vec![
+                RegexElement::Alternation(vec![
+                    RegexElement::Concatenation(vec![
+                        RegexElement::CharGroup {
+                            chars: BTreeSet::from(['B']),
+                            inverted: false,
+                        },
+                        RegexElement::CharGroup {
+                            chars: BTreeSet::from(['C']),
+                            inverted: false,
+                        },
+                    ]),
+                    //
+                    RegexElement::Concatenation(vec![
+                        RegexElement::CharGroup {
+                            chars: BTreeSet::from(['D']),
+                            inverted: false,
+                        },
+                        RegexElement::CharGroup {
+                            chars: BTreeSet::from(['E']),
+                            inverted: false,
+                        },
+                    ]),
+                ]),
+            ])]),
+        ])]);
+        let simplified = tree.simplify();
+
+        assert_eq!(
+            simplified,
+            RegexElement::Alternation(vec![RegexElement::Concatenation(vec![
+                RegexElement::CharGroup {
+                    chars: BTreeSet::from(['a']),
+                    inverted: false,
+                },
+                RegexElement::Alternation(vec![
+                    RegexElement::Concatenation(vec![
+                        RegexElement::CharGroup {
+                            chars: BTreeSet::from(['B',]),
+                            inverted: false,
+                        },
+                        RegexElement::CharGroup {
+                            chars: BTreeSet::from(['C',]),
+                            inverted: false,
+                        },
+                    ],),
+                    RegexElement::Concatenation(vec![
+                        RegexElement::CharGroup {
+                            chars: BTreeSet::from(['D',]),
+                            inverted: false,
+                        },
+                        RegexElement::CharGroup {
+                            chars: BTreeSet::from(['E',]),
+                            inverted: false,
+                        },
+                    ],),
+                ],),
+            ],),],)
+        );
+
+        // assert!(false);
+    }
+}
diff --git a/src/interegular/simple_parser.rs b/src/interegular/simple_parser.rs
new file mode 100644
index 00000000..321c938d
--- /dev/null
+++ b/src/interegular/simple_parser.rs
@@ -0,0 +1,366 @@
+#![allow(dead_code, unused_imports, unused_variables)]
+
+use std::collections::HashMap;
+use std::fmt::Display;
+use std::fmt::Formatter;
+use std::marker::PhantomData;
+
+#[derive(Debug, Clone, PartialEq)]
+pub struct NoMatch {
+    data: String,
+    index: usize,
+    expected: Vec<String>,
+}
+
+impl NoMatch {
+    #[must_use]
+    pub fn new(data: &str, index: usize, expected: Vec<String>) -> Self {
+        NoMatch {
+            data: data.to_string(),
+            index,
+            expected,
+        }
+    }
+}
+
+impl Display for NoMatch {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        let context_start = self.index.saturating_sub(10);
+        let context_end = (self.index + 10).min(self.data.len());
+        let got = if self.index < self.data.len() {
+            self.data[self.index..self.data.len().min(self.index + 5)].to_string()
+        } else {
+            "<end of input>".to_string()
+        };
+
+        write!(
+            f,
+            "Can not match at index {}. Got {:?}, expected any of {:?}.\nContext(data[{}:{}]): {:?}",
+            self.index,
+            got,
+            self.expected,
+            context_start,
+            context_end,
+            &self.data[context_start..context_end]
+        )
+    }
+}
+
+#[derive(Debug)]
+pub struct SimpleParser<T> {
+    pub data: String,
+    pub index: usize,
+    pub expected: HashMap<usize, Vec<String>>,
+    _phantom: PhantomData<T>,
+}
+
+impl<T> SimpleParser<T> {
+    #[must_use]
+    pub fn new(data: &str) -> Self {
+        SimpleParser {
+            data: data.to_string(),
+            index: 0,
+            expected: HashMap::new(),
+            _phantom: PhantomData,
+        }
+    }
+
+    pub fn peek_static(&mut self, expected: &str) -> bool {
+        if self.data[self.index..].starts_with(expected) {
+            true
+        } else {
+            self.expected
+                .entry(self.index)
+                .or_default()
+                .push(expected.to_string());
+            false
+        }
+    }
+
+    pub fn static_match(&mut self, expected: &str) -> Result<(), NoMatch> {
+        let len = expected.len();
+        if self.index + len <= self.data.len()
+            && &self.data[self.index..self.index + len] == expected
+        {
+            self.index += len;
+            Ok(())
+        } else {
+            self.expected
+                .entry(self.index)
+                .or_default()
+                .push(expected.to_string());
+            Err(NoMatch::new(
+                &self.data,
+                self.index,
+                vec![expected.to_string()],
+            ))
+        }
+    }
+
+    pub fn static_b(&mut self, expected: &str) -> bool {
+        let len = expected.len();
+        let end = if self.index + len > self.data.len() {
+            self.data.len()
+        } else {
+            self.index + len
+        };
+        let value = &self.data[self.index..end];
+        if value == expected {
+            self.index += len;
+            true
+        } else {
+            self.expected
+                .entry(self.index)
+                .or_default()
+                .push(expected.to_string());
+            false
+        }
+    }
+
+    pub fn anyof(&mut self, strings: &[&str]) -> Result<String, NoMatch> {
+        for &s in strings {
+            if self.static_b(s) {
+                return Ok(s.to_string());
+            }
+        }
+        Err(NoMatch::new(
+            &self.data,
+            self.index,
+            strings.iter().map(|&s| s.to_string()).collect(),
+        ))
+    }
+
+    pub fn anyof_b(&mut self, strings: &[&str]) -> bool {
+        for &s in strings {
+            if self.static_b(s) {
+                return true;
+            }
+        }
+        false
+    }
+
+    pub fn any(&mut self, length: usize) -> Result<String, NoMatch> {
+        if self.index + length <= self.data.len() {
+            let res = self.data[self.index..self.index + length].to_string();
+            self.index += length;
+            Ok(res)
+        } else {
+            self.expected
+                .entry(self.index)
+                .or_default()
+                .push(format!("<Any {length}>"));
+            Err(NoMatch::new(
+                &self.data,
+                self.index,
+                vec![format!("<Any {}>", length)],
+            ))
+        }
+    }
+
+    pub fn any_but(&mut self, strings: &[&str], length: usize) -> Result<String, NoMatch> {
+        if self.index + length <= self.data.len() {
+            let res = self.data[self.index..self.index + length].to_string();
+            if !strings.contains(&&res[..]) {
+                self.index += length;
+                Ok(res)
+            } else {
+                self.expected
+                    .entry(self.index)
+                    .or_default()
+                    .push(format!("<Any {length} except {strings:?}>"));
+                Err(NoMatch::new(
+                    &self.data,
+                    self.index,
+                    vec![format!("<Any {} except {:?}>", length, strings)],
+                ))
+            }
+        } else {
+            self.expected
+                .entry(self.index)
+                .or_default()
+                .push(format!("<Any {length} except {strings:?}>"));
+            Err(NoMatch::new(
+                &self.data,
+                self.index,
+                vec![format!("<Any {} except {:?}>", length, strings)],
+            ))
+        }
+    }
+
+    pub fn multiple(
+        &mut self,
+        chars: &str,
+        min: usize,
+        max: Option<usize>,
+    ) -> Result<String, NoMatch> {
+        let mut result = String::new();
+
+        // match minimum required characters
+        for _ in 0..min {
+            if let Some(c) = self.data[self.index..].chars().next() {
+                if chars.contains(c) {
+                    result.push(c);
+                    self.index += c.len_utf8();
+                } else {
+                    self.expected
+                        .entry(self.index)
+                        .or_default()
+                        .extend(chars.chars().map(|c| c.to_string()));
+                    return Err(NoMatch::new(
+                        &self.data,
+                        self.index,
+                        chars.chars().map(|c| c.to_string()).collect(),
+                    ));
+                }
+            } else {
+                return Err(NoMatch::new(
+                    &self.data,
+                    self.index,
+                    chars.chars().map(|c| c.to_string()).collect(),
+                ));
+            }
+        }
+
+        // match additional characters up to max
+        match max {
+            Some(max) => {
+                for _ in min..max {
+                    if let Some(c) = self.data[self.index..].chars().next() {
+                        if chars.contains(c) {
+                            result.push(c);
+                            self.index += c.len_utf8();
+                        } else {
+                            break;
+                        }
+                    } else {
+                        break;
+                    }
+                }
+            }
+            None => {
+                while let Some(c) = self.data[self.index..].chars().next() {
+                    if chars.contains(c) {
+                        result.push(c);
+                        self.index += c.len_utf8();
+                    } else {
+                        break;
+                    }
+                }
+            }
+        }
+
+        Ok(result)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_peek_static() {
+        let mut parser = SimpleParser::<()>::new("hello world");
+        assert!(parser.peek_static("hello"));
+        assert!(!parser.peek_static("world"));
+        assert_eq!(parser.index, 0);
+    }
+
+    #[test]
+    fn test_static_match() {
+        let mut parser = SimpleParser::<()>::new("hello world");
+        assert!(parser.static_match("hello").is_ok());
+        assert_eq!(parser.index, 5);
+        assert!(parser.static_b(" "));
+        assert_eq!(parser.index, 6);
+        assert!(parser.static_match("world").is_ok());
+        assert_eq!(parser.index, 11);
+        assert!(parser.static_match("!").is_err());
+    }
+
+    #[test]
+    fn test_static_b() {
+        let mut parser = SimpleParser::<()>::new("hello world");
+        assert!(parser.static_b("hello"));
+        assert_eq!(parser.index, 5);
+        assert!(parser.static_b(" "));
+        assert_eq!(parser.index, 6);
+        assert!(!parser.static_b("hello"));
+    }
+
+    #[test]
+    fn test_anyof() {
+        let mut parser = SimpleParser::<()>::new("hello world");
+        assert_eq!(parser.anyof(&["hi", "hello"]), Ok("hello".to_string()));
+        assert_eq!(parser.index, 5);
+        assert!(parser.anyof(&["hi", "hello"]).is_err());
+    }
+
+    #[test]
+    fn test_anyof_b() {
+        let mut parser = SimpleParser::<()>::new("hello world");
+        assert!(parser.anyof_b(&["hi", "hello"]));
+        assert_eq!(parser.index, 5);
+        assert!(!parser.anyof_b(&["hi", "hello"]));
+    }
+
+    #[test]
+    fn test_any() {
+        let mut parser = SimpleParser::<()>::new("hello world");
+        assert_eq!(parser.any(5), Ok("hello".to_string()));
+        assert_eq!(parser.index, 5);
+        assert_eq!(parser.any(1), Ok(" ".to_string()));
+        assert!(parser.any(10).is_err());
+    }
+
+    #[test]
+    fn test_any_but() {
+        let mut parser = SimpleParser::<()>::new("hello world");
+        assert_eq!(parser.any_but(&["world"], 5), Ok("hello".to_string()));
+        assert_eq!(parser.index, 5);
+        assert!(parser.any_but(&[" "], 1).is_err());
+    }
+
+    #[test]
+    fn test_multiple() {
+        let mut parser = SimpleParser::<()>::new("aaabbbccc");
+        assert_eq!(parser.multiple("ab", 2, Some(4)), Ok("aaab".to_string()));
+        assert_eq!(parser.index, 4);
+        assert_eq!(parser.multiple("b", 1, None), Ok("bb".to_string()));
+        assert_eq!(parser.index, 6);
+        assert!(parser.multiple("d", 1, None).is_err());
+    }
+
+    #[test]
+    fn test_no_match_display() {
+        let no_match = NoMatch::new(
+            //
+            "hello world",
+            6,
+            vec!["a".to_string(), "b".to_string()],
+        );
+        let display = format!("{no_match}");
+        assert!(display.contains("index 6"));
+        assert!(display.contains("Got \"world\""));
+        assert!(display.contains("expected any of [\"a\", \"b\"]"));
+        assert!(display.contains("Context(data[0:11]): \"hello world\""));
+    }
+
+    #[test]
+    fn test_parser_with_complex_input() {
+        let mut parser = SimpleParser::<()>::new("key1=value1;key2=value2");
+        assert!(parser.static_b("key1"));
+        assert!(parser.static_b("="));
+        assert_eq!(
+            parser.multiple("abcdefghijklmnopqrstuvwxyz123456789", 1, None),
+            Ok("value1".to_string())
+        );
+        assert!(parser.static_b(";"));
+        assert!(parser.static_b("key2"));
+        assert!(parser.static_b("="));
+        assert_eq!(
+            parser.multiple("abcdefghijklmnopqrstuvwxyz123456789", 1, None),
+            Ok("value2".to_string())
+        );
+        assert_eq!(parser.index, parser.data.len());
+    }
+}
diff --git a/src/lib.rs b/src/lib.rs
index 4a68a55a..186c8e80 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1,3 +1,4 @@
+pub mod interegular;
 pub mod json_schema;
 pub mod regex;
 
diff --git a/src/python_bindings/mod.rs b/src/python_bindings/mod.rs
index b7c7c2e0..f677be90 100644
--- a/src/python_bindings/mod.rs
+++ b/src/python_bindings/mod.rs
@@ -1,4 +1,8 @@
+use crate::interegular::fsm::Fsm;
+use crate::interegular::patterns::parse_pattern;
+use crate::interegular::patterns::RegexElement;
 use crate::json_schema;
+use crate::primitives::TransitionKey;
 use crate::regex::get_token_transition_keys;
 use crate::regex::get_vocabulary_transition_keys;
 use crate::regex::state_scan_tokens;
@@ -9,7 +13,7 @@ use pyo3::prelude::*;
 use pyo3::types::PyDict;
 use pyo3::wrap_pyfunction;
 use serde_json::Value;
-use std::collections::{HashMap, HashSet};
+use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet};
 
 #[pyclass]
 pub struct FSMInfo {
@@ -212,6 +216,359 @@ impl PyVocabulary {
     }
 }
 
+#[pyclass]
+#[derive(Clone)]
+struct PyLiteral {
+    #[pyo3(get)]
+    value: char,
+}
+
+#[pymethods]
+impl PyLiteral {
+    fn __repr__(&self) -> PyResult<String> {
+        Ok(format!("Literal('{}')", self.value))
+    }
+}
+
+#[pyclass]
+#[derive(Clone)]
+struct PyCharGroup {
+    #[pyo3(get)]
+    chars: Vec<char>,
+    #[pyo3(get)]
+    inverted: bool,
+}
+
+#[pymethods]
+impl PyCharGroup {
+    fn __repr__(&self) -> PyResult<String> {
+        Ok(format!(
+            "CharGroup(chars='{:?}', inverted={})",
+            self.chars, self.inverted
+        ))
+    }
+}
+
+#[pyclass]
+struct PyRepeated {
+    #[pyo3(get)]
+    element: PyObject,
+    #[pyo3(get)]
+    min: usize,
+    #[pyo3(get)]
+    max: Option<usize>,
+}
+
+#[pymethods]
+impl PyRepeated {
+    fn __repr__(&self) -> PyResult<String> {
+        Ok(format!(
+            "Repeated(element='{}', min={}, max={:?})",
+            self.element, self.min, self.max
+        ))
+    }
+}
+
+#[pyclass]
+struct PyConcatenation {
+    #[pyo3(get)]
+    elements: Vec<PyObject>,
+}
+
+#[pymethods]
+impl PyConcatenation {
+    fn __repr__(&self) -> PyResult<String> {
+        Ok(format!("Concatenation(elements='{:?}')", self.elements))
+    }
+}
+
+#[pyclass]
+struct PyAlternation {
+    #[pyo3(get)]
+    elements: Vec<PyObject>,
+}
+
+#[pymethods]
+impl PyAlternation {
+    fn __repr__(&self) -> PyResult<String> {
+        Ok(format!("Alternation(elements='{:?}')", self.elements))
+    }
+}
+
+#[pyclass]
+struct PyCapture {
+    #[pyo3(get)]
+    element: PyObject,
+}
+
+#[pymethods]
+impl PyCapture {
+    fn __repr__(&self) -> PyResult<String> {
+        Ok(format!("Capture(element='{}')", self.element))
+    }
+}
+
+#[pyclass]
+struct PyGroup {
+    #[pyo3(get)]
+    element: PyObject,
+}
+
+#[pymethods]
+impl PyGroup {
+    fn __repr__(&self) -> PyResult<String> {
+        Ok(format!("Group(element='{}')", self.element))
+    }
+}
+
+#[pyclass]
+#[derive(Clone)]
+struct PyAnchor {
+    #[pyo3(get)]
+    anchor_type: String,
+}
+
+#[pymethods]
+impl PyAnchor {
+    fn __repr__(&self) -> PyResult<String> {
+        Ok(format!("Anchor(anchor_type='{}')", self.anchor_type))
+    }
+}
+
+#[pyclass]
+struct PyFlag {
+    #[pyo3(get)]
+    element: PyObject,
+    #[pyo3(get)]
+    added: Vec<String>,
+    #[pyo3(get)]
+    removed: Vec<String>,
+}
+
+impl Clone for PyRepeated {
+    fn clone(&self) -> Self {
+        Python::with_gil(|py| PyRepeated {
+            element: self.element.clone_ref(py),
+            min: self.min,
+            max: self.max,
+        })
+    }
+}
+
+impl Clone for PyConcatenation {
+    fn clone(&self) -> Self {
+        Python::with_gil(|py| PyConcatenation {
+            elements: self.elements.iter().map(|e| e.clone_ref(py)).collect(),
+        })
+    }
+}
+
+impl Clone for PyAlternation {
+    fn clone(&self) -> Self {
+        Python::with_gil(|py| PyAlternation {
+            elements: self.elements.iter().map(|e| e.clone_ref(py)).collect(),
+        })
+    }
+}
+
+impl Clone for PyCapture {
+    fn clone(&self) -> Self {
+        Python::with_gil(|py| PyCapture {
+            element: self.element.clone_ref(py),
+        })
+    }
+}
+
+impl Clone for PyGroup {
+    fn clone(&self) -> Self {
+        Python::with_gil(|py| PyGroup {
+            element: self.element.clone_ref(py),
+        })
+    }
+}
+
+impl Clone for PyFlag {
+    fn clone(&self) -> Self {
+        Python::with_gil(|py| PyFlag {
+            element: self.element.clone_ref(py),
+            added: self.added.clone(),
+            removed: self.removed.clone(),
+        })
+    }
+}
+
+fn convert_to_py_regex_element(py: Python, element: &RegexElement) -> PyResult<PyObject> {
+    match element {
+        RegexElement::Literal(c) => Ok(PyLiteral { value: *c }.into_py(py)),
+        RegexElement::CharGroup { chars, inverted } => Ok(PyCharGroup {
+            chars: chars.iter().cloned().collect(),
+            inverted: *inverted,
+        }
+        .into_py(py)),
+        RegexElement::Repeated { element, min, max } => {
+            let py_element = convert_to_py_regex_element(py, element)?;
+            Ok(PyRepeated {
+                element: py_element,
+                min: *min,
+                max: *max,
+            }
+            .into_py(py))
+        }
+        RegexElement::Concatenation(elements) => {
+            let py_elements: PyResult<Vec<PyObject>> = elements
+                .iter()
+                .map(|e| convert_to_py_regex_element(py, e))
+                .collect();
+            Ok(PyConcatenation {
+                elements: py_elements?,
+            }
+            .into_py(py))
+        }
+        RegexElement::Alternation(elements) => {
+            let py_elements: PyResult<Vec<PyObject>> = elements
+                .iter()
+                .map(|e| convert_to_py_regex_element(py, e))
+                .collect();
+            Ok(PyAlternation {
+                elements: py_elements?,
+            }
+            .into_py(py))
+        }
+        RegexElement::Capture(element) => {
+            let py_element = convert_to_py_regex_element(py, element)?;
+            Ok(PyCapture {
+                element: py_element,
+            }
+            .into_py(py))
+        }
+        RegexElement::Group(element) => {
+            let py_element = convert_to_py_regex_element(py, element)?;
+            Ok(PyGroup {
+                element: py_element,
+            }
+            .into_py(py))
+        }
+        RegexElement::Anchor(anchor_type) => Ok(PyAnchor {
+            anchor_type: format!("{:?}", anchor_type),
+        }
+        .into_py(py)),
+        RegexElement::Flag {
+            element,
+            added,
+            removed,
+        } => {
+            let py_element = convert_to_py_regex_element(py, element)?;
+            Ok(PyFlag {
+                element: py_element,
+                added: added.iter().map(|f| format!("{:?}", f)).collect(),
+                removed: removed.iter().map(|f| format!("{:?}", f)).collect(),
+            }
+            .into_py(py))
+        }
+    }
+}
+
+#[pyfunction(name = "parse_pattern")]
+#[pyo3(text_signature = "(pattern: &str)")]
+pub fn parse_pattern_internal(py: Python, pattern: &str) -> PyResult<PyObject> {
+    match parse_pattern(pattern) {
+        Ok(regex_element) => convert_to_py_regex_element(py, &regex_element),
+        Err(_) => Err(PyValueError::new_err("Invalid pattern")),
+    }
+}
+
+#[pyclass]
+pub struct InteregularFSMInfo {
+    #[pyo3(get)]
+    initial: u32,
+    #[pyo3(get)]
+    finals: HashSet<u32>,
+    #[pyo3(get)]
+    states: HashSet<u32>,
+    #[pyo3(get)]
+    map: HashMap<u32, HashMap<u32, u32>>,
+    #[pyo3(get)]
+    symbol_mapping: HashMap<char, usize>,
+    #[pyo3(get)]
+    by_transition: HashMap<usize, Vec<char>>,
+}
+
+use crate::interegular::fsm::Alphabet;
+use crate::interegular::patterns::Flag;
+
+#[pyfunction(name = "parse_pattern_to_fsm")]
+#[pyo3(text_signature = "(pattern: &str)")]
+pub fn parse_pattern_to_fsm_internal(pattern: &str) -> PyResult<InteregularFSMInfo> {
+    let regex_element =
+        parse_pattern(pattern).map_err(|_| PyValueError::new_err("Invalid pattern"))?;
+
+    let prefix_postfix = None;
+    let flags = None;
+
+    let default_alphabet = Alphabet::<char>::default();
+    let empty_flags: BTreeSet<Flag> = BTreeSet::new();
+    let patterns_alphabet: Alphabet<char> = regex_element.get_alphabet(&empty_flags);
+
+    // TODO: this is a hack to build a alphabet with the same symbols as the patterns
+    // and ensure that \0 is the anything symbol at 0. However, this is not a good solution
+    // and should be handled by an improved alphabet implementation
+    let mut my_new_symbol_mapping = BTreeMap::new();
+    my_new_symbol_mapping.insert('\0', 0 as usize); // add \0 as the anything symbol at 0
+
+    let mut counter = 1;
+    for (symbol, _) in patterns_alphabet.symbol_mapping.iter() {
+        if *symbol != '\0' {
+            my_new_symbol_mapping.insert(*symbol, counter as usize);
+            counter += 1;
+        }
+    }
+
+    let alphabet = Alphabet::new(my_new_symbol_mapping);
+    let fsm_info = regex_element.to_fsm(Some(alphabet.clone()), prefix_postfix, flags);
+
+    // convert into u32 for python
+    let map: HashMap<u32, HashMap<u32, u32>> = fsm_info
+        .map
+        .iter()
+        .map(|(key, map)| {
+            // let u32_key = u32::from(*key);
+            let u32_key = *key as u32;
+            let map_as_u32s = map
+                .iter()
+                .map(|(key, value)| {
+                    (
+                        // u32::from(*key), u32::from(*value)
+                        *key as u32,
+                        *value as u32,
+                    )
+                })
+                .collect();
+            (u32_key, map_as_u32s)
+        })
+        .collect();
+
+    let python_symbol_mapping: HashMap<char, usize> = alphabet
+        .symbol_mapping
+        .iter()
+        .map(|(k, v)| (*k, (*v).into()))
+        .collect();
+
+    let python_by_transition: HashMap<usize, Vec<char>> = alphabet
+        .by_transition
+        .iter()
+        .map(|(k, v)| (usize::from(*k), v.iter().map(|&c| c).collect()))
+        .collect();
+
+    Ok(InteregularFSMInfo {
+        initial: fsm_info.initial as u32,
+        finals: fsm_info.finals.iter().map(|f| (*f as u32)).collect(),
+        states: fsm_info.states.iter().map(|s| (*s as u32)).collect(),
+        map,
+        symbol_mapping: python_symbol_mapping,
+        by_transition: python_by_transition,
+    })
+}
+
 #[pymodule]
 fn outlines_core_rs(m: &Bound<'_, PyModule>) -> PyResult<()> {
     m.add_function(wrap_pyfunction!(walk_fsm_py, m)?)?;
@@ -219,6 +576,19 @@ fn outlines_core_rs(m: &Bound<'_, PyModule>) -> PyResult<()> {
     m.add_function(wrap_pyfunction!(get_token_transition_keys_py, m)?)?;
     m.add_function(wrap_pyfunction!(get_vocabulary_transition_keys_py, m)?)?;
     m.add_function(wrap_pyfunction!(create_fsm_index_end_to_end_py, m)?)?;
+    m.add_function(wrap_pyfunction!(parse_pattern_internal, m)?)?;
+    m.add_class::<PyLiteral>()?;
+    m.add_class::<PyCharGroup>()?;
+    m.add_class::<PyRepeated>()?;
+    m.add_class::<PyConcatenation>()?;
+    m.add_class::<PyAlternation>()?;
+    m.add_class::<PyCapture>()?;
+    m.add_class::<PyGroup>()?;
+    m.add_class::<PyAnchor>()?;
+    m.add_class::<PyFlag>()?;
+
+    m.add_function(wrap_pyfunction!(parse_pattern_to_fsm_internal, m)?)?;
+    m.add_class::<InteregularFSMInfo>()?;
 
     m.add_class::<FSMInfo>()?;
 
diff --git a/tests/fsm/test_guide.py b/tests/fsm/test_guide.py
index 174063b0..bbdc3502 100644
--- a/tests/fsm/test_guide.py
+++ b/tests/fsm/test_guide.py
@@ -1,7 +1,8 @@
-import interegular
 import pytest
 from outlines_core.fsm.guide import Generate, RegexGuide, StopAtEOSGuide, Write
 
+import interegular
+
 
 def assert_expected_tensor_ids(tensor, ids):
     assert len(tensor) == len(ids)
diff --git a/tests/fsm/test_json_schema.py b/tests/fsm/test_json_schema.py
index bd269ae0..8bc4b95d 100644
--- a/tests/fsm/test_json_schema.py
+++ b/tests/fsm/test_json_schema.py
@@ -2,7 +2,6 @@
 import re
 from typing import List, Literal, Union
 
-import interegular
 import pytest
 from outlines_core.fsm.json_schema import (
     BOOLEAN,
@@ -22,6 +21,8 @@
 )
 from pydantic import BaseModel, Field, constr
 
+import interegular
+
 
 def test_function_basic():
     def test_function(foo: str, bar: List[int]):
diff --git a/tests/fsm/test_regex.py b/tests/fsm/test_regex.py
index ed8e2fca..bcd1500f 100644
--- a/tests/fsm/test_regex.py
+++ b/tests/fsm/test_regex.py
@@ -1,9 +1,8 @@
-import interegular
 import pytest
-from outlines_core.fsm.outlines_core_rs import Vocabulary
 from outlines_core.fsm.regex import (
     BetterAlphabet,
     BetterFSM,
+    Vocabulary,
     _walk_fsm,
     create_fsm_index_end_to_end,
     create_fsm_index_tokenizer,
@@ -16,6 +15,8 @@
 from outlines_core.models.transformers import TransformerTokenizer
 from transformers import AutoTokenizer
 
+import interegular
+
 
 def identity(s):
     return s
@@ -143,7 +144,10 @@ def test_walk_fsm_multi_bytes(transform):
 
     res = tuple(
         walk_fsm_from_token_str_rust(
-            regex_fsm, merge_symbols(transform("😂")), regex_fsm.initial, full_match=True
+            regex_fsm,
+            merge_symbols(transform("😂")),
+            regex_fsm.initial,
+            full_match=True,
         )
     )
     assert res[-1:] == (1,)
diff --git a/tests/interegular/test_parse_outline_patterns.py b/tests/interegular/test_parse_outline_patterns.py
new file mode 100644
index 00000000..c28154da
--- /dev/null
+++ b/tests/interegular/test_parse_outline_patterns.py
@@ -0,0 +1,752 @@
+import pytest
+from outlines_core.fsm.json_schema import (
+    INTEGER,
+    NULL,
+    WHITESPACE,
+    STRING,  #
+    STRING_INNER,  #
+    BOOLEAN,
+    NUMBER,
+)
+from interegular.patterns import Pattern as InteregularPattern
+from interegular.patterns import _CharGroup, _Concatenation, _Repeated
+from outlines_core.fsm.regex import parse_pattern
+import interegular
+
+
+def convert_to_interegular(element):
+    if isinstance(element, InteregularPattern):
+        return element
+
+    element_type = type(element).__name__
+
+    if element_type == "PyLiteral":
+        # TODO: handle the negated case if needed
+        return _CharGroup(frozenset(element.value), negated=False)
+
+    elif element_type == "PyCharGroup":
+        return _CharGroup(frozenset(element.chars), negated=element.inverted)
+
+    elif element_type == "PyRepeated":
+        base = convert_to_interegular(element.element)
+        return _Repeated(base, element.min, element.max)
+
+    elif element_type == "PyConcatenation":
+        parts = [convert_to_interegular(e) for e in element.elements]
+        return _Concatenation(parts)
+
+    elif element_type == "PyAlternation":
+        options = [convert_to_interegular(e) for e in element.elements]
+        return InteregularPattern(options)
+
+    elif element_type == "PyCapture":
+        # interegular doesn't have a direct equivalent for Capture
+        # we'll just convert the inner element
+        return convert_to_interegular(element.element)
+
+    elif element_type == "PyGroup":
+        # similar to Capture, we'll just convert the inner element
+        return convert_to_interegular(element.element)
+
+    elif element_type == "PyAnchor":
+        # TODO: handle the different types of anchors if needed
+        # interegular doesn't have a direct equivalent for Anchor either
+        # in this case, we'll just raise an error
+        raise NotImplementedError("Anchors are not supported in interegular")
+
+    elif element_type == "PyFlag":
+        return convert_to_interegular(element.element)
+
+    else:
+        raise ValueError(f"Unhandled element type: {element_type}")
+
+
+def deep_compare(pattern1, pattern2):
+    if isinstance(pattern1, InteregularPattern) != isinstance(
+        pattern2, InteregularPattern
+    ):
+        return False
+
+    if isinstance(pattern1, InteregularPattern):
+        if len(pattern1.options) != len(pattern2.options):
+            return False
+        return all(
+            deep_compare(opt1, opt2)
+            for opt1, opt2 in zip(pattern1.options, pattern2.options)
+        )
+
+    elif isinstance(pattern1, _Concatenation):
+        if len(pattern1.parts) != len(pattern2.parts):
+            return False
+        return all(
+            deep_compare(elem1, elem2)
+            for elem1, elem2 in zip(pattern1.parts, pattern2.parts)
+        )
+
+    elif isinstance(pattern1, _CharGroup):
+        return pattern1.chars == pattern2.chars and pattern1.negated == pattern2.negated
+
+    elif isinstance(pattern1, _Repeated):
+        return (
+            deep_compare(pattern1.base, pattern2.base)
+            and pattern1.min == pattern2.min
+            and pattern1.max == pattern2.max
+        )
+
+    else:
+        raise ValueError(f"Unhandled pattern type: {type(pattern1)}")
+
+
+# test parameters copied from tests/fsm/test_json_schema.py to align with the test
+@pytest.mark.parametrize(
+    "schema,regex,examples",
+    [
+        # String
+        (
+            {"title": "Foo", "type": "string"},
+            STRING,
+            [
+                ("unquotedstring", False),
+                ('"(parenthesized_string)"', True),
+                ('"malformed) parenthesis (((() string"', True),
+                ('"quoted_string"', True),
+                (r'"escape_\character"', False),
+                (r'"double_\\escape"', True),
+                (r'"\n"', False),
+                (r'"\\n"', True),
+                (r'"unescaped " quote"', False),
+                (r'"escaped \" quote"', True),
+            ],
+        ),
+        # String with maximum length
+        (
+            {"title": "Foo", "type": "string", "maxLength": 3},
+            f'"{STRING_INNER}{{,3}}"',
+            [('"ab"', True), ('"a""', False), ('"abcd"', False)],
+        ),
+        # String with minimum length
+        (
+            {"title": "Foo", "type": "string", "minLength": 3},
+            f'"{STRING_INNER}{{3,}}"',
+            [('"ab"', False), ('"abcd"', True), ('"abc""', False)],
+        ),
+        # String with both minimum and maximum length
+        (
+            {"title": "Foo", "type": "string", "minLength": 3, "maxLength": 5},
+            f'"{STRING_INNER}{{3,5}}"',
+            [('"ab"', False), ('"abcd"', True), ('"abcdef""', False)],
+        ),
+        # String defined by a regular expression
+        (
+            {"title": "Foo", "type": "string", "pattern": r"^[a-z]$"},
+            r'("[a-z]")',
+            [('"a"', True), ('"1"', False)],
+        ),
+        # Boolean
+        (
+            {"title": "Foo", "type": "boolean"},
+            BOOLEAN,
+            [
+                ("true", True),
+                ("false", True),
+                ("null", False),
+                ("0", False),
+            ],
+        ),
+        # Null
+        (
+            {"title": "Foo", "type": "null"},
+            NULL,
+            [
+                ("null", True),
+                ("true", False),
+                ("0", False),
+            ],
+        ),
+        # Const string
+        (
+            {"title": "Foo", "const": "Marc", "type": "string"},
+            '"Marc"',
+            [('"Marc"', True), ('"Jean"', False), ('"John"', False)],
+        ),
+        # Make sure strings are escaped with regex escaping
+        (
+            {"title": "Foo", "const": ".*", "type": "string"},
+            r'"\.\*"',
+            [('".*"', True), (r'"\s*"', False), (r'"\.\*"', False)],
+        ),
+        # Make sure strings are escaped with JSON escaping
+        (
+            {"title": "Foo", "const": '"', "type": "string"},
+            r'"\\""',
+            [('"\\""', True), ('"""', False)],
+        ),
+        # Const integer
+        (
+            {"title": "Foo", "const": 0, "type": "integer"},
+            "0",
+            [("0", True), ("1", False), ("a", False)],
+        ),
+        # Const float
+        (
+            {"title": "Foo", "const": 0.2, "type": "float"},
+            r"0\.2",
+            [("0.2", True), ("032", False)],
+        ),
+        # Const boolean
+        (
+            {"title": "Foo", "const": True, "type": "boolean"},
+            "true",
+            [("true", True), ("True", False)],
+        ),
+        # Const null
+        (
+            {"title": "Foo", "const": None, "type": "null"},
+            "null",
+            [("null", True), ("None", False), ("", False)],
+        ),
+        # TODO: very close - just nested
+        # Enum string
+        (
+            {"title": "Foo", "enum": ["Marc", "Jean"], "type": "string"},
+            # '("Marc"|"Jean")',
+            "(A|B)",
+            [('"Marc"', True), ('"Jean"', True), ('"John"', False)],
+        ),
+        # TODO: very close - just nested
+        # Make sure strings are escaped with regex and JSON escaping
+        (
+            {"title": "Foo", "enum": [".*", r"\s*"], "type": "string"},
+            r'("\.\*"|"\\\\s\*")',
+            [('".*"', True), (r'"\\s*"', True), (r'"\.\*"', False)],
+        ),
+        # TODO: very close - just nested
+        # Enum integer
+        (
+            {"title": "Foo", "enum": [0, 1], "type": "integer"},
+            "(0|1)",
+            [("0", True), ("1", True), ("a", False)],
+        ),
+        # Enum mix of types
+        (
+            {"title": "Foo", "enum": [6, 5.3, "potato", True, None]},
+            r'(6|5\.3|"potato"|true|null)',
+            [
+                ("6", True),
+                ("5.3", True),
+                ('"potato"', True),
+                ("true", True),
+                ("null", True),
+                ("523", False),
+                ("True", False),
+                ("None", False),
+            ],
+        ),
+        # integer
+        (
+            {
+                "title": "Foo",
+                "type": "object",
+                "properties": {"count": {"title": "Count", "type": "integer"}},
+                "required": ["count"],
+            },
+            '\\{[ ]?"count"[ ]?:[ ]?(-)?(0|[1-9][0-9]*)[ ]?\\}',
+            [('{ "count": 100 }', True)],
+        ),
+        # integer with minimum digits
+        (
+            {
+                "title": "Foo",
+                "type": "object",
+                "properties": {
+                    "count": {"title": "Count", "type": "integer", "minDigits": 3}
+                },
+                "required": ["count"],
+            },
+            '\\{[ ]?"count"[ ]?:[ ]?(-)?(0|[1-9][0-9]{2,})[ ]?\\}',
+            [('{ "count": 10 }', False), ('{ "count": 100 }', True)],
+        ),
+        # integer with maximum digits
+        (
+            {
+                "title": "Foo",
+                "type": "object",
+                "properties": {
+                    "count": {"title": "Count", "type": "integer", "maxDigits": 3}
+                },
+                "required": ["count"],
+            },
+            '\\{[ ]?"count"[ ]?:[ ]?(-)?(0|[1-9][0-9]{,2})[ ]?\\}',
+            [('{ "count": 100 }', True), ('{ "count": 1000 }', False)],
+        ),
+        # integer with minimum and maximum digits
+        (
+            {
+                "title": "Foo",
+                "type": "object",
+                "properties": {
+                    "count": {
+                        "title": "Count",
+                        "type": "integer",
+                        "minDigits": 3,
+                        "maxDigits": 5,
+                    }
+                },
+                "required": ["count"],
+            },
+            '\\{[ ]?"count"[ ]?:[ ]?(-)?(0|[1-9][0-9]{2,4})[ ]?\\}',
+            [
+                ('{ "count": 10 }', False),
+                ('{ "count": 100 }', True),
+                ('{ "count": 10000 }', True),
+                ('{ "count": 100000 }', False),
+            ],
+        ),
+        # number
+        (
+            {
+                "title": "Foo",
+                "type": "object",
+                "properties": {"count": {"title": "Count", "type": "number"}},
+                "required": ["count"],
+            },
+            '\\{[ ]?"count"[ ]?:[ ]?((-)?(0|[1-9][0-9]*))(\\.[0-9]+)?([eE][+-][0-9]+)?[ ]?\\}',
+            [('{ "count": 100 }', True), ('{ "count": 100.5 }', True)],
+        ),
+        # number with min and max integer digits
+        (
+            {
+                "title": "Foo",
+                "type": "object",
+                "properties": {
+                    "count": {
+                        "title": "Count",
+                        "type": "number",
+                        "minDigitsInteger": 3,
+                        "maxDigitsInteger": 5,
+                    }
+                },
+                "required": ["count"],
+            },
+            '\\{[ ]?"count"[ ]?:[ ]?((-)?(0|[1-9][0-9]{2,4}))(\\.[0-9]+)?([eE][+-][0-9]+)?[ ]?\\}',
+            [
+                ('{ "count": 10.005 }', False),
+                ('{ "count": 100.005 }', True),
+                ('{ "count": 10000.005 }', True),
+                ('{ "count": 100000.005 }', False),
+            ],
+        ),
+        # number with min and max fraction digits
+        (
+            {
+                "title": "Foo",
+                "type": "object",
+                "properties": {
+                    "count": {
+                        "title": "Count",
+                        "type": "number",
+                        "minDigitsFraction": 3,
+                        "maxDigitsFraction": 5,
+                    }
+                },
+                "required": ["count"],
+            },
+            '\\{[ ]?"count"[ ]?:[ ]?((-)?(0|[1-9][0-9]*))(\\.[0-9]{3,5})?([eE][+-][0-9]+)?[ ]?\\}',
+            [
+                ('{ "count": 1.05 }', False),
+                ('{ "count": 1.005 }', True),
+                ('{ "count": 1.00005 }', True),
+                ('{ "count": 1.000005 }', False),
+            ],
+        ),
+        # number with min and max exponent digits
+        (
+            {
+                "title": "Foo",
+                "type": "object",
+                "properties": {
+                    "count": {
+                        "title": "Count",
+                        "type": "number",
+                        "minDigitsExponent": 3,
+                        "maxDigitsExponent": 5,
+                    }
+                },
+                "required": ["count"],
+            },
+            '\\{[ ]?"count"[ ]?:[ ]?((-)?(0|[1-9][0-9]*))(\\.[0-9]+)?([eE][+-][0-9]{3,5})?[ ]?\\}',
+            [
+                ('{ "count": 1.05e1 }', False),
+                ('{ "count": 1.05e+001 }', True),
+                ('{ "count": 1.05e-00001 }', True),
+                ('{ "count": 1.05e0000001 }', False),
+            ],
+        ),
+        # number with min and max integer, fraction and exponent digits
+        (
+            {
+                "title": "Foo",
+                "type": "object",
+                "properties": {
+                    "count": {
+                        "title": "Count",
+                        "type": "number",
+                        "minDigitsInteger": 3,
+                        "maxDigitsInteger": 5,
+                        "minDigitsFraction": 3,
+                        "maxDigitsFraction": 5,
+                        "minDigitsExponent": 3,
+                        "maxDigitsExponent": 5,
+                    }
+                },
+                "required": ["count"],
+            },
+            '\\{[ ]?"count"[ ]?:[ ]?((-)?(0|[1-9][0-9]{2,4}))(\\.[0-9]{3,5})?([eE][+-][0-9]{3,5})?[ ]?\\}',
+            [
+                ('{ "count": 1.05e1 }', False),
+                ('{ "count": 100.005e+001 }', True),
+                ('{ "count": 10000.00005e-00001 }', True),
+                ('{ "count": 100000.000005e0000001 }', False),
+            ],
+        ),
+        # array
+        (
+            {"title": "Foo", "type": "array", "items": {"type": "number"}},
+            rf"\[{WHITESPACE}(({NUMBER})(,{WHITESPACE}({NUMBER})){{0,}})?{WHITESPACE}\]",
+            [("[1e+9,1.3]", True), ("[]", True), ("[1", False)],
+        ),
+        # array with a set length of 1
+        (
+            {
+                "title": "Foo",
+                "type": "array",
+                "items": {"type": "integer"},
+                "minItems": 1,
+                "maxItems": 1,
+            },
+            rf"\[{WHITESPACE}(({INTEGER})(,{WHITESPACE}({INTEGER})){{0,0}}){WHITESPACE}\]",
+            [("[1]", True), ("[1,2]", False), ('["a"]', False), ("[]", False)],
+        ),
+        # array with a set length greather than 1
+        (
+            {
+                "title": "Foo",
+                "type": "array",
+                "items": {"type": "integer"},
+                "minItems": 3,
+                "maxItems": 3,
+            },
+            rf"\[{WHITESPACE}(({INTEGER})(,{WHITESPACE}({INTEGER})){{2,2}}){WHITESPACE}\]",
+            [("[1]", False), ("[]", False), ("[1,2,3]", True), ("[1,2,3,4]", False)],
+        ),
+        # array with length 0
+        (
+            {
+                "title": "Foo",
+                "type": "array",
+                "items": {"type": "integer"},
+                "minItems": 0,
+                "maxItems": 0,
+            },
+            rf"\[{WHITESPACE}\]",
+            [("[1]", False), ("[]", True), ("[1,2,3]", False), ("[1,2,3,4]", False)],
+        ),
+        # object
+        (
+            {
+                "title": "TestSchema",
+                "type": "object",
+                "properties": {
+                    "test_dict": {
+                        "title": "Test Dict",
+                        "additionalProperties": {"type": "string"},
+                        "type": "object",
+                    }
+                },
+                "required": ["test_dict"],
+            },
+            rf"""\{{{WHITESPACE}"test_dict"{WHITESPACE}:{WHITESPACE}\{{{WHITESPACE}({STRING}{WHITESPACE}:{WHITESPACE}{STRING}({WHITESPACE},{WHITESPACE}{STRING}{WHITESPACE}:{WHITESPACE}{STRING}){{0,}})?{WHITESPACE}\}}{WHITESPACE}\}}""",
+            [
+                ("""{ "test_dict":{"foo":"bar","baz": "bif"}}""", True),
+                ("""{ "test_dict":{"foo":"bar" }}""", True),
+                ("""{ "test_dict":{}}""", True),
+                ("""{ "WRONG_KEY":{}}""", False),
+                ("""{ "test_dict":{"wrong_type" 1}}""", False),
+            ],
+        ),
+        # object containing object
+        (
+            {
+                "title": "TestSchema",
+                "type": "object",
+                "properties": {
+                    "test_dict": {
+                        "title": "Test Dict",
+                        "additionalProperties": {
+                            "additionalProperties": {"type": "integer"},
+                            "type": "object",
+                        },
+                        "type": "object",
+                    }
+                },
+                "required": ["test_dict"],
+            },
+            rf"""\{{{WHITESPACE}"test_dict"{WHITESPACE}:{WHITESPACE}\{{{WHITESPACE}({STRING}{WHITESPACE}:{WHITESPACE}\{{{WHITESPACE}({STRING}{WHITESPACE}:{WHITESPACE}{INTEGER}({WHITESPACE},{WHITESPACE}{STRING}{WHITESPACE}:{WHITESPACE}{INTEGER}){{0,}})?{WHITESPACE}\}}({WHITESPACE},{WHITESPACE}{STRING}{WHITESPACE}:{WHITESPACE}\{{{WHITESPACE}({STRING}{WHITESPACE}:{WHITESPACE}{INTEGER}({WHITESPACE},{WHITESPACE}{STRING}{WHITESPACE}:{WHITESPACE}{INTEGER}){{0,}})?{WHITESPACE}\}}){{0,}})?{WHITESPACE}\}}{WHITESPACE}\}}""",
+            [
+                (
+                    """{"test_dict": {"foo": {"bar": 123, "apple": 99}, "baz": {"bif": 456}}}""",
+                    True,
+                ),
+                (
+                    """{"test_dict": {"anykey": {"anykey": 123}, "anykey2": {"bif": 456}}}""",
+                    True,
+                ),
+                ("""{"test_dict": {}}""", True),
+                ("""{"test_dict": {"dict of empty dicts are ok": {} }}""", True),
+                (
+                    """{"test_dict": {"anykey": {"ONLY Dict[Dict]": 123}, "No Dict[int]" 1: }}""",
+                    False,
+                ),
+            ],
+        ),
+        # oneOf
+        (
+            {
+                "title": "Foo",
+                "oneOf": [{"type": "string"}, {"type": "number"}, {"type": "boolean"}],
+            },
+            rf'((?:"{STRING_INNER}*")|(?:{NUMBER})|(?:{BOOLEAN}))',
+            [
+                ("12.3", True),
+                ("true", True),
+                ('"a"', True),
+                ("null", False),
+                ("", False),
+                ("12true", False),
+                ('1.3"a"', False),
+                ('12.3true"a"', False),
+            ],
+        ),
+        # anyOf
+        (
+            {
+                "title": "Foo",
+                "anyOf": [{"type": "string"}, {"type": "integer"}],
+            },
+            rf"({STRING}|{INTEGER})",
+            [("12", True), ('"a"', True), ('1"a"', False)],
+        ),
+        # allOf
+        (
+            {
+                "title": "Foo",
+                "allOf": [{"type": "string"}, {"type": "integer"}],
+            },
+            rf"({STRING}{INTEGER})",
+            [('"a"1', True), ('"a"', False), ('"1"', False)],
+        ),
+        # Tuple / prefixItems
+        (
+            {
+                "title": "Foo",
+                "prefixItems": [{"type": "string"}, {"type": "integer"}],
+            },
+            rf"\[{WHITESPACE}{STRING}{WHITESPACE},{WHITESPACE}{INTEGER}{WHITESPACE}\]",
+            [('["a", 1]', True), ('["a", 1, 1]', False), ("[]", False)],
+        ),
+        # Nested schema
+        (
+            {
+                "title": "Bar",
+                "type": "object",
+                "properties": {
+                    "fuzz": {
+                        "title": "Foo",
+                        "type": "object",
+                        "properties": {"spam": {"title": "Spam", "type": "integer"}},
+                        "required": ["spam"],
+                    }
+                },
+                "required": ["fuzz"],
+            },
+            f'\\{{[ ]?"fuzz"[ ]?:[ ]?\\{{[ ]?"spam"[ ]?:[ ]?{INTEGER}[ ]?\\}}[ ]?\\}}',
+            [('{ "fuzz": { "spam": 100 }}', True)],
+        ),
+        # Schema with a reference
+        (
+            {
+                "title": "User",
+                "type": "object",
+                "properties": {
+                    "user_id": {"title": "User Id", "type": "integer"},
+                    "name": {"title": "Name", "type": "string"},
+                    "a": {"$ref": "#/properties/name"},
+                },
+                "required": ["user_id", "name", "a"],
+            },
+            f'\\{{[ ]?"user_id"[ ]?:[ ]?{INTEGER}[ ]?,[ ]?"name"[ ]?:[ ]?{STRING}[ ]?,[ ]?"a"[ ]?:[ ]?{STRING}[ ]?\\}}',
+            [('{"user_id": 100, "name": "John", "a": "Marc"}', True)],
+        ),
+        (
+            {
+                "title": "User",
+                "type": "object",
+                "$defs": {"name": {"title": "Name2", "type": "string"}},
+                "properties": {
+                    "user_id": {"title": "User Id", "type": "integer"},
+                    "name": {"title": "Name", "type": "string"},
+                    "name2": {"$ref": "#/$defs/name"},
+                },
+                "required": ["user_id", "name", "name2"],
+            },
+            f'\\{{[ ]?"user_id"[ ]?:[ ]?{INTEGER}[ ]?,[ ]?"name"[ ]?:[ ]?{STRING}[ ]?,[ ]?"name2"[ ]?:[ ]?{STRING}[ ]?\\}}',
+            [('{"user_id": 100, "name": "John", "name2": "Marc"}', True)],
+        ),
+        (
+            {
+                "$id": "customer",
+                "$schema": "https://json-schema.org/draft/2020-12/schema",
+                "title": "Customer",
+                "type": "object",
+                "properties": {
+                    "name": {"type": "string"},
+                    "last_name": {"type": "string"},
+                    "address": {"$ref": "customer#/$defs/address"},
+                },
+                "required": [
+                    "name",
+                    "first_name",
+                    "last_name",
+                    "address",
+                    "shipping_address",
+                    "billing_address",
+                ],
+                "$defs": {
+                    "address": {
+                        "title": "Address",
+                        "$schema": "http://json-schema.org/draft-07/schema#",
+                        "type": "object",
+                        "properties": {
+                            "city": {"type": "string"},
+                        },
+                        "required": ["street_address", "city", "state"],
+                        "definitions": {
+                            "state": {
+                                "type": "object",
+                                "title": "State",
+                                "properties": {"name": {"type": "string"}},
+                                "required": ["name"],
+                            }
+                        },
+                    }
+                },
+            },
+            f'\\{{[ ]?"name"[ ]?:[ ]?{STRING}[ ]?,[ ]?"last_name"[ ]?:[ ]?{STRING}[ ]?,[ ]?"address"[ ]?:[ ]?\\{{[ ]?"city"[ ]?:[ ]?{STRING}[ ]?\\}}[ ]?\\}}',
+            [
+                (
+                    '{"name": "John", "last_name": "Doe", "address": {"city": "Paris"}}',
+                    True,
+                )
+            ],
+        ),
+        # Optional properties
+        # Last required property in first position
+        (
+            {
+                "properties": {
+                    "name": {"type": "string"},
+                    "age": {"anyOf": [{"type": "integer"}, {"type": "null"}]},
+                    "weapon": {"anyOf": [{"type": "string"}, {"type": "null"}]},
+                },
+                "required": ["name"],
+                "title": "Character",
+                "type": "object",
+            },
+            f'\\{{[ ]?"name"[ ]?:[ ]?{STRING}([ ]?,[ ]?"age"[ ]?:[ ]?({INTEGER}|null))?([ ]?,[ ]?"weapon"[ ]?:[ ]?({STRING}|null))?[ ]?\\}}',
+            [
+                ('{ "name" : "Player" }', True),
+                ('{ "name" : "Player", "weapon" : "sword" }', True),
+                ('{ "age" : 10, "weapon" : "sword" }', False),
+            ],
+        ),
+        # Last required property in middle position
+        (
+            {
+                "properties": {
+                    "name": {"type": "string"},
+                    "age": {"anyOf": [{"type": "integer"}, {"type": "null"}]},
+                    "weapon": {"type": "string"},
+                    "strength": {"anyOf": [{"type": "integer"}, {"type": "null"}]},
+                },
+                "required": ["name", "weapon"],
+                "title": "Character",
+                "type": "object",
+            },
+            f'\\{{[ ]?"name"[ ]?:[ ]?{STRING}[ ]?,([ ]?"age"[ ]?:[ ]?({INTEGER}|null)[ ]?,)?[ ]?"weapon"[ ]?:[ ]?{STRING}([ ]?,[ ]?"strength"[ ]?:[ ]?({INTEGER}|null))?[ ]?\\}}',
+            [
+                ('{ "name" : "Player" , "weapon" : "sword" }', True),
+                (
+                    '{ "name" : "Player", "age" : 10, "weapon" : "sword" , "strength" : 10 }',
+                    True,
+                ),
+                ('{ "weapon" : "sword" }', False),
+            ],
+        ),
+        # Last required property in last position
+        (
+            {
+                "properties": {
+                    "name": {"anyOf": [{"type": "string"}, {"type": "null"}]},
+                    "age": {"type": "integer"},
+                    "armor": {"type": "string"},
+                    "strength": {"anyOf": [{"type": "integer"}, {"type": "null"}]},
+                    "weapon": {"title": "Weapon", "type": "string"},
+                },
+                "required": ["age", "armor", "weapon"],
+                "title": "Character",
+                "type": "object",
+            },
+            f'\\{{([ ]?"name"[ ]?:[ ]?({STRING}|null)[ ]?,)?[ ]?"age"[ ]?:[ ]?{INTEGER}[ ]?,[ ]?"armor"[ ]?:[ ]?{STRING}[ ]?,([ ]?"strength"[ ]?:[ ]?({INTEGER}|null)[ ]?,)?[ ]?"weapon"[ ]?:[ ]?{STRING}[ ]?\\}}',
+            [
+                (
+                    '{ "name" : "Player", "age" : 10, "armor" : "plate", "strength" : 11, "weapon" : "sword" }',
+                    True,
+                ),
+                ('{ "age" : 10, "armor" : "plate", "weapon" : "sword" }', True),
+                (
+                    '{ "name" : "Kahlhanbeh", "armor" : "plate", "weapon" : "sword" }',
+                    False,
+                ),
+            ],
+        ),
+        # All properties are optional
+        (
+            {
+                "properties": {
+                    "name": {"anyOf": [{"type": "string"}, {"type": "null"}]},
+                    "age": {"anyOf": [{"type": "integer"}, {"type": "null"}]},
+                    "strength": {"anyOf": [{"type": "integer"}, {"type": "null"}]},
+                },
+                "title": "Character",
+                "type": "object",
+            },
+            f'\\{{([ ]?"name"[ ]?:[ ]?({STRING}|null)([ ]?,[ ]?"age"[ ]?:[ ]?({INTEGER}|null))?([ ]?,[ ]?"strength"[ ]?:[ ]?({INTEGER}|null))?|([ ]?"name"[ ]?:[ ]?({STRING}|null)[ ]?,)?[ ]?"age"[ ]?:[ ]?({INTEGER}|null)([ ]?,[ ]?"strength"[ ]?:[ ]?({INTEGER}|null))?|([ ]?"name"[ ]?:[ ]?({STRING}|null)[ ]?,)?([ ]?"age"[ ]?:[ ]?({INTEGER}|null)[ ]?,)?[ ]?"strength"[ ]?:[ ]?({INTEGER}|null))?[ ]?\\}}',
+            [
+                ('{ "name" : "Player" }', True),
+                ('{ "name" : "Player", "age" : 10, "strength" : 10 }', True),
+                ('{ "age" : 10, "strength" : 10 }', True),
+                ("{ }", True),
+            ],
+        ),
+    ],
+)
+def test_match(schema, regex, examples):
+    pattern = interegular.parse_pattern(regex)
+    _pattern = parse_pattern(regex)
+    converted = convert_to_interegular(_pattern)
+
+    print("Regex: ", regex)
+    print(f"Pattern: \n{pattern}")
+    print(f"Converted: \n{converted}")
+
+    assert deep_compare(pattern, converted)
diff --git a/tests/interegular/test_parse_pattern.py b/tests/interegular/test_parse_pattern.py
new file mode 100644
index 00000000..43e24d4b
--- /dev/null
+++ b/tests/interegular/test_parse_pattern.py
@@ -0,0 +1,138 @@
+import pytest
+from interegular.patterns import Pattern as InteregularPattern
+from interegular.patterns import _CharGroup, _Concatenation, _Repeated
+from outlines_core.fsm.regex import parse_pattern
+
+import interegular
+
+
+def convert_to_interegular(element):
+    if isinstance(element, InteregularPattern):
+        return element
+
+    element_type = type(element).__name__
+
+    if element_type == "PyLiteral":
+        # TODO: handle the negated case if needed
+        return _CharGroup(frozenset(element.value), negated=False)
+
+    elif element_type == "PyCharGroup":
+        return _CharGroup(frozenset(element.chars), negated=element.inverted)
+
+    elif element_type == "PyRepeated":
+        base = convert_to_interegular(element.element)
+        return _Repeated(base, element.min, element.max)
+
+    elif element_type == "PyConcatenation":
+        parts = [convert_to_interegular(e) for e in element.elements]
+        return _Concatenation(parts)
+
+    elif element_type == "PyAlternation":
+        options = [convert_to_interegular(e) for e in element.elements]
+        return InteregularPattern(options)
+
+    elif element_type == "PyCapture":
+        # interegular doesn't have a direct equivalent for Capture
+        # we'll just convert the inner element
+        return convert_to_interegular(element.element)
+
+    elif element_type == "PyGroup":
+        # similar to Capture, we'll just convert the inner element
+        return convert_to_interegular(element.element)
+
+    elif element_type == "PyAnchor":
+        # TODO: handle the different types of anchors if needed
+        # interegular doesn't have a direct equivalent for Anchor either
+        # in this case, we'll just raise an error
+        raise NotImplementedError("Anchors are not supported in interegular")
+
+    elif element_type == "PyFlag":
+        return convert_to_interegular(element.element)
+
+    else:
+        raise ValueError(f"Unhandled element type: {element_type}")
+
+
+def deep_compare(pattern1, pattern2):
+    if type(pattern1) != type(pattern2):
+        return False
+
+    if isinstance(pattern1, InteregularPattern):
+        if len(pattern1.options) != len(pattern2.options):
+            return False
+        return all(
+            deep_compare(opt1, opt2)
+            for opt1, opt2 in zip(pattern1.options, pattern2.options)
+        )
+
+    elif isinstance(pattern1, _Concatenation):
+        if len(pattern1.parts) != len(pattern2.parts):
+            return False
+        return all(
+            deep_compare(elem1, elem2)
+            for elem1, elem2 in zip(pattern1.parts, pattern2.parts)
+        )
+
+    elif isinstance(pattern1, _CharGroup):
+        return pattern1.chars == pattern2.chars and pattern1.negated == pattern2.negated
+
+    elif isinstance(pattern1, _Repeated):
+        return (
+            deep_compare(pattern1.base, pattern2.base)
+            and pattern1.min == pattern2.min
+            and pattern1.max == pattern2.max
+        )
+
+    else:
+        raise ValueError(f"Unhandled pattern type: {type(pattern1)}")
+
+
+@pytest.mark.parametrize(
+    "regex_string",
+    [
+        "ab",
+        "a|b",
+        "[ab]",
+        "a*b",
+        "a*b+c?",
+        "c?",
+        "(ab|cd)*",
+        "[a-z0-9]+",
+        "foo(bar|baz)*qux",
+        "(a|b|c){1,3}",
+        "[^aeiou]{2,4}",
+    ],
+)
+def test_parse_pattern(regex_string):
+    ref_pattern = interegular.parse_pattern(regex_string)
+    custom_pattern = parse_pattern(regex_string)
+    converted_pattern = convert_to_interegular(custom_pattern)
+
+    print(f"\nRegex: {regex_string}")
+    print(f"Reference pattern: {ref_pattern}")
+    print(f"Converted pattern: {converted_pattern}")
+
+    are_equal = deep_compare(ref_pattern, converted_pattern)
+
+    return are_equal
+
+
+# TODO: remove if not needed
+# tests copied so they can be run as a standalone script
+if __name__ == "__main__":
+    test_cases = [
+        "ab",
+        "a|b",
+        "[ab]",
+        "a*b",
+        "a*b+c?",
+        "c?",
+        "(ab|cd)*",
+        "[a-z0-9]+",
+        "foo(bar|baz)*qux",
+        "(a|b|c){1,3}",
+        "[^aeiou]{2,4}",
+    ]
+
+    all_passed = all(test_parse_pattern(case) for case in test_cases)
+    print(f"All tests passed: {all_passed}")
diff --git a/tests/interegular/test_parse_pattern_to_fsm.py b/tests/interegular/test_parse_pattern_to_fsm.py
new file mode 100644
index 00000000..e4482fc4
--- /dev/null
+++ b/tests/interegular/test_parse_pattern_to_fsm.py
@@ -0,0 +1,200 @@
+import pytest
+
+# TODO: THIS IS A WORK IN PROGRESS AND WILL BE COMPLETELY REFACTORED BEFORE MERGING
+from interegular.fsm import anything_else
+from outlines_core.fsm.regex import parse_pattern_to_fsm
+
+import interegular
+
+
+class InteregularFSMInfo:
+    def __init__(self, initial, finals, states, map, symbol_mapping, by_transition):
+        self.initial = initial
+        self.finals = finals
+        self.states = states
+        self.map = map
+        self.symbol_mapping = symbol_mapping
+        self.by_transition = by_transition
+
+
+def map_states_with_symbols(state_map, symbol_mapping):
+    inv_symbol_mapping = {v: k for k, v in symbol_mapping.items()}
+
+    mapped_states = {}
+    for state, transitions in state_map.items():
+        mapped_transitions = {}
+        for symbol, next_state in transitions.items():
+            mapped_symbol = inv_symbol_mapping.get(symbol, symbol)
+            mapped_transitions[mapped_symbol] = next_state
+        mapped_states[state] = mapped_transitions
+
+    return mapped_states
+
+
+def make_fsm_comparable(fsm):
+    # Create a new symbol mapping
+    new_symbol_mapping = {}
+    for symbol, value in fsm.symbol_mapping.items():
+        if symbol == "\x00":
+            new_symbol_mapping[anything_else] = value
+        else:
+            new_symbol_mapping[symbol] = value
+
+    # Create a new map
+    new_map = {}
+    for state, transitions in fsm.map.items():
+        new_transitions = {}
+        for symbol, next_state in transitions.items():
+            if symbol == b"\x00":
+                new_transitions[anything_else] = next_state
+            else:
+                new_transitions[symbol] = next_state
+        new_map[state] = new_transitions
+
+    new_fsm = InteregularFSMInfo(
+        states=fsm.states,
+        initial=fsm.initial,
+        finals=fsm.finals,
+        map=new_map,
+        symbol_mapping=new_symbol_mapping,
+        by_transition=fsm.by_transition,
+    )
+
+    return new_fsm
+
+
+def compare_sets(set1, set2):
+    # ensure that the sets are equal
+    return frozenset(set1) == frozenset(set2)
+
+
+def sort_map(map):
+    for key in map:
+        if isinstance(map[key], dict):
+            map[key] = sort_map(map[key])
+    return dict(sorted(map.items()))
+
+
+@pytest.mark.parametrize(
+    "pattern",
+    [
+        "a",
+        "ab",
+        "a|b",
+        # "[ab]",
+        # "aaaaa",
+        # "davidholtz",
+        # "a*b+c?",
+        # "(ab|cd)*",
+        # "[a-z0-9]+",
+        # "foo(bar|baz)*qux",
+        # "(a|b|c){1,3}",
+        # "[^aeiou]{2,4}",
+    ],
+)
+def test_parse_pattern_to_fsm(pattern):
+    fsm = parse_pattern_to_fsm(pattern)
+    fsm = make_fsm_comparable(fsm)
+
+    ref_pattern = interegular.parse_pattern(pattern)
+
+    # # interegulat alphabet
+    # symbol_map = {
+    #     "z": 0,
+    #     "a": 1,
+    #     "i": 2,
+    #     "t": 3,
+    #     anything_else: 4,
+    #     "d": 5,
+    #     "v": 6,
+    #     "h": 7,
+    #     "l": 8,
+    #     "o": 9,
+    # }
+    # my_alphabet = Alphabet(symbol_map)
+
+    my_alphabet = None
+
+    ref_fsm = ref_pattern.to_fsm(my_alphabet)
+
+    # TODO: prefer asserts once fsm building is implemented
+    # Compare FSMs
+    # assert fsm.states == ref_fsm.states
+    # assert fsm.initial == ref_fsm.initial
+    # assert fsm.finals == ref_fsm.finals
+    # assert fsm.map == ref_fsm.map
+
+    # make maps deterministic (sort by key)
+    fsm_map = sort_map(fsm.map)
+    ref_map = sort_map(ref_fsm.map)
+
+    equal_states = frozenset(fsm.states) == frozenset(ref_fsm.states)
+    equal_initial = fsm.initial == ref_fsm.initial
+    equal_finals = frozenset(fsm.finals) == frozenset(ref_fsm.finals)
+    equal_map = map_states_with_symbols(
+        fsm.map, fsm.symbol_mapping
+    ) == map_states_with_symbols(ref_fsm.map, ref_fsm.alphabet._symbol_mapping)
+
+    print()
+    if equal_states and equal_initial and equal_finals and equal_map:
+        print(f"✅ Test passed for pattern: {pattern}")
+    else:
+        print(f"❌ Test failed for pattern: {pattern}")
+
+    print("fsm: symbol_mapping\n", fsm.symbol_mapping)
+    print("fsm: by_transition\n", fsm.by_transition)
+
+    print("ref: symbol_mapping\n", ref_fsm.alphabet._symbol_mapping)
+    print("ref: by_transition\n", ref_fsm.alphabet.by_transition)
+
+    print("States")
+    print(f"  fsm: {frozenset(fsm.states)}")
+    print(f"  ref: {ref_fsm.states}")
+
+    print("Initial")
+    print(f"  fsm: {fsm.initial}")
+    print(f"  ref: {ref_fsm.initial}")
+
+    print("Finals")
+    print(f"  fsm: {frozenset(fsm.finals)}")
+    print(f"  ref: {ref_fsm.finals}")
+
+    print("Map")
+
+    print(f"  fsm: {fsm_map}")
+    print(f"  ref: {ref_map}")
+
+    print("Map with symbols")
+    fsm_map_with_symbols = map_states_with_symbols(fsm_map, fsm.symbol_mapping)
+    print(f"  fsm: {sort_map(fsm_map_with_symbols)}")
+
+    ref_map_with_symbols = map_states_with_symbols(
+        ref_map, ref_fsm.alphabet._symbol_mapping
+    )
+    print(f"  ref: {sort_map(ref_map_with_symbols)}")
+
+    return True
+
+
+# TODO: remove if not needed
+# tests copied so they can be run as a standalone script
+if __name__ == "__main__":
+    test_cases = [
+        "a",
+        "ab",
+        # "a|b",
+        # "[ab]",
+        # TODO: long simple patterns (should work)
+        # "aaaaa",
+        # "davidholtz",
+        # TODO: revisit these cases
+        # "a*b+c?",
+        # "(ab|cd)*",
+        # "[a-z0-9]+",
+        # "foo(bar|baz)*qux",
+        # "(a|b|c){1,3}",
+        # "[^aeiou]{2,4}"
+    ]
+
+    all_passed = all(test_parse_pattern_to_fsm(case) for case in test_cases)
+    # print(f"All tests passed: {all_passed}")