feat: add shift logic

scie-grammar/src/rule/abstract_rule.rs

 use crate::grammar::Grammar;
-use crate::rule::{IRuleRegistry, RegExpSourceList, CompiledRule};
+use crate::rule::{RegExpSourceList, CompiledRule};
 use core::fmt;
 use dyn_clone::{clone_trait_object, DynClone};
 

scie-grammar/src/rule/begin_end_rule.rs

@@ -81,11 +81,21 @@ impl AbstractRule for BeginEndRule {
             // todo: figured cached issues
             let mut cached_compiled_patterns = RegExpSourceList::new();
             self.collect_patterns_recursive(grammar, &mut cached_compiled_patterns, true);
+
+            if let Some(apply_end) = self.apply_end_pattern_last {
+                if apply_end {
+                    cached_compiled_patterns.push(self._end.clone());
+                } else {
+                    cached_compiled_patterns.unshift(self._end.clone());
+                }
+            } else {
+                cached_compiled_patterns.unshift(self._end.clone());
+            }
+
             self._cached_compiled_patterns = Some(cached_compiled_patterns);
         }
 
         // todo: support for hasBackReferences
-
         self._cached_compiled_patterns.as_ref().unwrap().compile(grammar, allow_a, allow_g)
     }
 }

scie-grammar/src/rule/mod.rs

@@ -28,8 +28,6 @@ use serde::Serialize;
 // todo: trait with types
 // https://users.rust-lang.org/t/impl-trait-with-generic-function-for-generic-struct/27083/2
 pub trait IRuleRegistry {
-    // type Output;
-    // fn method(&self) -> Self::Output;
     fn register_id(&mut self) -> i32;
     fn get_rule(&mut self, pattern_id: i32) -> Box<dyn AbstractRule>;
     fn register_rule(&mut self, result: Box<dyn AbstractRule>) -> Box<dyn AbstractRule>;
@@ -89,6 +87,14 @@ impl RegExpSourceList {
         }
     }
 
+    pub fn unshift(&mut self, item: RegExpSource) {
+        self._items.push(item.clone());
+        self._items.rotate_right(1);
+        if item.has_anchor {
+            self._has_anchors = true;
+        }
+    }
+
     pub fn compile(&self, grammar: &mut Grammar, allow_a: bool, allow_g: bool) -> CompiledRule {
         let rules = self._items.clone().into_iter().map(|x| {
             x.source.parse().unwrap_or(0)