1 files changed, 32 insertions, 49 deletions
diff --git a/src/util/mdx_collect.rs b/src/util/mdx_collect.rs
index 73ead51..02921a4 100644
--- a/src/util/mdx_collect.rs
+++ b/src/util/mdx_collect.rs
@@ -1,70 +1,53 @@
 //! Collect info for MDX.
 
-use crate::event::{Kind, Name, Point};
-use crate::tokenizer::Tokenizer;
+use crate::event::{Event, Kind, Name};
 use crate::util::slice::{Position, Slice};
 use alloc::{string::String, vec, vec::Vec};
 
-pub type Location<'a> = (usize, &'a Point);
+pub type Stop = (usize, usize);
 
-pub struct Result<'a> {
-    pub start: &'a Point,
+#[derive(Debug)]
+pub struct Result {
     pub value: String,
-    pub locations: Vec<Location<'a>>,
+    pub stops: Vec<Stop>,
 }
 
-pub fn collect<'a>(tokenizer: &'a Tokenizer, from: usize, names: &[Name]) -> Result<'a> {
+pub fn collect(
+    events: &[Event],
+    bytes: &[u8],
+    from: usize,
+    names: &[Name],
+    stop: &[Name],
+) -> Result {
     let mut result = Result {
-        start: &tokenizer.events[from].point,
         value: String::new(),
-        locations: vec![],
+        stops: vec![],
     };
     let mut index = from;
-    let mut acc = 0;
 
-    while index < tokenizer.events.len() {
-        if tokenizer.events[index].kind == Kind::Enter
-            && names.contains(&tokenizer.events[index].name)
-        {
-            // Include virtual spaces.
-            let value = Slice::from_position(
-                tokenizer.parse_state.bytes,
-                &Position {
-                    start: &tokenizer.events[index].point,
-                    end: &tokenizer.events[index + 1].point,
-                },
-            )
-            .serialize();
-            acc += value.len();
-            result.locations.push((acc, &tokenizer.events[index].point));
-            result.value.push_str(&value);
-        }
-
-        index += 1;
-    }
-
-    result
-}
-
-// Turn an index of `result.value` into a point in the whole document.
-pub fn place_to_point(result: &Result, place: usize) -> Point {
-    let mut index = 0;
-    let mut point = result.start;
-    let mut rest = place;
-
-    while index < result.locations.len() {
-        point = result.locations[index].1;
-
-        if result.locations[index].0 > place {
+    while index < events.len() {
+        if events[index].kind == Kind::Enter {
+            if names.contains(&events[index].name) {
+                // Include virtual spaces, and assume void.
+                let value = Slice::from_position(
+                    bytes,
+                    &Position {
+                        start: &events[index].point,
+                        end: &events[index + 1].point,
+                    },
+                )
+                .serialize();
+                result
+                    .stops
+                    .push((result.value.len(), events[index].point.index));
+                result.value.push_str(&value);
+            }
+        } else if stop.contains(&events[index].name) {
             break;
         }
 
-        rest = place - result.locations[index].0;
         index += 1;
     }
 
-    let mut point = point.clone();
-    point.column += rest;
-    point.index += rest;
-    point
+    result
 }