diff --git a/crates/djls-templates/src/ast.rs b/crates/djls-templates/src/ast.rs
index 08210aef..9c9590dc 100644
--- a/crates/djls-templates/src/ast.rs
+++ b/crates/djls-templates/src/ast.rs
@@ -59,7 +59,7 @@ impl Default for LineOffsets {
 pub enum Node<'db> {
     Tag {
         name: TagName<'db>,
-        bits: Vec<String>,
+        bits: Vec<TagBit<'db>>,
         span: Span,
     },
     Comment {
@@ -129,6 +129,11 @@ pub struct TagName<'db> {
     pub text: String,
 }
 
+#[salsa::interned(debug)]
+pub struct TagBit<'db> {
+    pub text: String,
+}
+
 #[salsa::interned(debug)]
 pub struct VariableName<'db> {
     pub text: String,
diff --git a/crates/djls-templates/src/lexer.rs b/crates/djls-templates/src/lexer.rs
index e417c739..197ab1df 100644
--- a/crates/djls-templates/src/lexer.rs
+++ b/crates/djls-templates/src/lexer.rs
@@ -1,3 +1,4 @@
+use crate::ast::LineOffsets;
 use crate::db::Db as TemplateDb;
 use crate::tokens::Token;
 use crate::tokens::TokenContent;
@@ -14,7 +15,6 @@ pub struct Lexer<'db> {
     source: String,
     start: usize,
     current: usize,
-    line: usize,
 }
 
 impl<'db> Lexer<'db> {
@@ -25,12 +25,12 @@ impl<'db> Lexer<'db> {
             source: String::from(source),
             start: 0,
             current: 0,
-            line: 1,
         }
     }
 
-    pub fn tokenize(&mut self) -> Vec<Token<'db>> {
+    pub fn tokenize(&mut self) -> (Vec<Token<'db>>, LineOffsets) {
         let mut tokens = Vec::new();
+        let mut line_offsets = LineOffsets::default();
 
         while !self.is_at_end() {
             self.start = self.current;
@@ -53,9 +53,9 @@ impl<'db> Lexer<'db> {
             };
 
             match self.peek_previous() {
-                '\n' => self.line += 1,
+                '\n' => line_offsets.add_line(u32::try_from(self.current).unwrap_or(u32::MAX)),
                 '\r' => {
-                    self.line += 1;
+                    line_offsets.add_line(u32::try_from(self.current).unwrap_or(u32::MAX));
                     if self.peek() == '\n' {
                         self.current += 1;
                     }
@@ -68,7 +68,7 @@ impl<'db> Lexer<'db> {
 
         tokens.push(Token::Eof);
 
-        tokens
+        (tokens, line_offsets)
     }
 
     fn lex_django_construct(
@@ -255,7 +255,7 @@ mod tests {
         let db = TestDatabase::new();
         let source = r#"<div class="container" id="main" disabled></div>"#;
         let mut lexer = Lexer::new(&db, source);
-        let tokens = lexer.tokenize();
+        let (tokens, _) = lexer.tokenize();
         let snapshot = TokenSnapshotVec(tokens).to_snapshot(&db);
         insta::assert_yaml_snapshot!(snapshot);
     }
@@ -265,7 +265,7 @@ mod tests {
         let db = TestDatabase::new();
         let source = "{{ user.name|default:\"Anonymous\"|title }}";
         let mut lexer = Lexer::new(&db, source);
-        let tokens = lexer.tokenize();
+        let (tokens, _) = lexer.tokenize();
         let snapshot = TokenSnapshotVec(tokens).to_snapshot(&db);
         insta::assert_yaml_snapshot!(snapshot);
     }
@@ -275,7 +275,7 @@ mod tests {
         let db = TestDatabase::new();
         let source = "{% if user.is_staff %}Admin{% else %}User{% endif %}";
         let mut lexer = Lexer::new(&db, source);
-        let tokens = lexer.tokenize();
+        let (tokens, _) = lexer.tokenize();
         let snapshot = TokenSnapshotVec(tokens).to_snapshot(&db);
         insta::assert_yaml_snapshot!(snapshot);
     }
@@ -294,7 +294,7 @@ mod tests {
     /* CSS comment */
 </style>";
         let mut lexer = Lexer::new(&db, source);
-        let tokens = lexer.tokenize();
+        let (tokens, _) = lexer.tokenize();
         let snapshot = TokenSnapshotVec(tokens).to_snapshot(&db);
         insta::assert_yaml_snapshot!(snapshot);
     }
@@ -310,7 +310,7 @@ mod tests {
     console.log(x);
 </script>"#;
         let mut lexer = Lexer::new(&db, source);
-        let tokens = lexer.tokenize();
+        let (tokens, _) = lexer.tokenize();
         let snapshot = TokenSnapshotVec(tokens).to_snapshot(&db);
         insta::assert_yaml_snapshot!(snapshot);
     }
@@ -325,7 +325,7 @@ mod tests {
     }
 </style>"#;
         let mut lexer = Lexer::new(&db, source);
-        let tokens = lexer.tokenize();
+        let (tokens, _) = lexer.tokenize();
         let snapshot = TokenSnapshotVec(tokens).to_snapshot(&db);
         insta::assert_yaml_snapshot!(snapshot);
     }
@@ -339,7 +339,7 @@ mod tests {
 <!-- html comment -->
 <div>text</div>";
         let mut lexer = Lexer::new(&db, source);
-        let tokens = lexer.tokenize();
+        let (tokens, _) = lexer.tokenize();
         let snapshot = TokenSnapshotVec(tokens).to_snapshot(&db);
         insta::assert_yaml_snapshot!(snapshot);
     }
@@ -378,7 +378,7 @@ mod tests {
 </body>
 </html>"#;
         let mut lexer = Lexer::new(&db, source);
-        let tokens = lexer.tokenize();
+        let (tokens, _) = lexer.tokenize();
         let snapshot = TokenSnapshotVec(tokens).to_snapshot(&db);
         insta::assert_yaml_snapshot!(snapshot);
     }
@@ -388,7 +388,7 @@ mod tests {
         let db = TestDatabase::new();
         let source = "<style>body { color: blue; ";
         let mut lexer = Lexer::new(&db, source);
-        let tokens = lexer.tokenize();
+        let (tokens, _) = lexer.tokenize();
         let snapshot = TokenSnapshotVec(tokens).to_snapshot(&db);
         insta::assert_yaml_snapshot!(snapshot);
     }
diff --git a/crates/djls-templates/src/lib.rs b/crates/djls-templates/src/lib.rs
index a311cd6b..d1c2c9cf 100644
--- a/crates/djls-templates/src/lib.rs
+++ b/crates/djls-templates/src/lib.rs
@@ -75,14 +75,14 @@ use validation::TagValidator;
 #[salsa::tracked]
 fn lex_template(db: &dyn Db, file: SourceFile) -> TokenStream<'_> {
     if file.kind(db) != FileKind::Template {
-        return TokenStream::new(db, vec![]);
+        return TokenStream::new(db, vec![], LineOffsets::default());
     }
 
     let text_arc = djls_workspace::db::source_text(db, file);
     let text = text_arc.as_ref();
 
-    let tokens = Lexer::new(db, text).tokenize();
-    TokenStream::new(db, tokens)
+    let (tokens, line_offsets) = Lexer::new(db, text).tokenize();
+    TokenStream::new(db, tokens, line_offsets)
 }
 
 /// Parse tokens into an AST.
diff --git a/crates/djls-templates/src/parser.rs b/crates/djls-templates/src/parser.rs
index ac6b6132..492e838b 100644
--- a/crates/djls-templates/src/parser.rs
+++ b/crates/djls-templates/src/parser.rs
@@ -2,10 +2,12 @@ use serde::Serialize;
 use thiserror::Error;
 
 use crate::ast::FilterName;
+use crate::ast::LineOffsets;
 use crate::ast::Node;
 use crate::ast::NodeList;
 use crate::ast::NodeListError;
 use crate::ast::Span;
+use crate::ast::TagBit;
 use crate::ast::TagName;
 use crate::ast::VariableName;
 use crate::db::Db as TemplateDb;
@@ -15,6 +17,7 @@ use crate::tokens::TokenStream;
 pub struct Parser<'db> {
     db: &'db dyn TemplateDb,
     tokens: Vec<Token<'db>>,
+    line_offsets: LineOffsets,
     current: usize,
     errors: Vec<ParserError>,
 }
@@ -25,6 +28,7 @@ impl<'db> Parser<'db> {
         Self {
             db,
             tokens: tokens.stream(db).clone(),
+            line_offsets: tokens.line_offsets(db).clone(),
             current: 0,
             errors: Vec::new(),
         }
@@ -32,17 +36,6 @@ impl<'db> Parser<'db> {
 
     pub fn parse(&mut self) -> Result<(NodeList<'db>, Vec<ParserError>), ParserError> {
         let mut nodelist = Vec::new();
-        let mut line_offsets = crate::ast::LineOffsets::default();
-
-        let tokens = &self.tokens;
-        for token in tokens {
-            if matches!(token, Token::Newline { .. }) {
-                let offset = token.offset();
-                if let Some(offset) = offset {
-                    line_offsets.add_line(offset + 1);
-                }
-            }
-        }
 
         while !self.is_at_end() {
             match self.next_node() {
@@ -58,7 +51,7 @@ impl<'db> Parser<'db> {
             }
         }
 
-        let ast = NodeList::new(self.db, nodelist, line_offsets);
+        let ast = NodeList::new(self.db, nodelist, self.line_offsets.clone());
 
         Ok((ast, std::mem::take(&mut self.errors)))
     }
@@ -69,8 +62,8 @@ impl<'db> Parser<'db> {
         match token {
             Token::Comment { .. } => self.parse_comment(),
             Token::Eof { .. } => Err(ParserError::stream_error(StreamError::AtEnd)),
-            Token::Block { .. } => self.parse_django_block(),
-            Token::Variable { .. } => self.parse_django_variable(),
+            Token::Block { .. } => self.parse_block(),
+            Token::Variable { .. } => self.parse_variable(),
             Token::Error { .. } => self.parse_error(),
             Token::Newline { .. } | Token::Text { .. } | Token::Whitespace { .. } => {
                 self.parse_text()
@@ -83,60 +76,78 @@ impl<'db> Parser<'db> {
 
         Ok(Node::Comment {
             content: token.content(self.db),
-            span: Span::from_token(&token, self.db),
+            span: Span::from_token(token, self.db),
         })
     }
 
     fn parse_error(&mut self) -> Result<Node<'db>, ParserError> {
         let token = self.peek_previous()?;
 
-        if let Token::Error {
-            content, offset, ..
-        } = token
-        {
-            let error_text = content.text(self.db).clone();
-
-            Err(ParserError::MalformedConstruct {
-                position: offset,
-                content: error_text,
-            })
-        } else {
-            Err(ParserError::InvalidSyntax {
+        match token {
+            Token::Error {
+                content, offset, ..
+            } => {
+                let error_text = content.text(self.db).clone();
+                Err(ParserError::MalformedConstruct {
+                    position: *offset,
+                    content: error_text,
+                })
+            }
+            _ => Err(ParserError::InvalidSyntax {
                 context: "Expected Error token".to_string(),
-            })
+            }),
         }
     }
 
-    pub fn parse_django_block(&mut self) -> Result<Node<'db>, ParserError> {
+    pub fn parse_block(&mut self) -> Result<Node<'db>, ParserError> {
         let token = self.peek_previous()?;
 
-        let content = token.content(self.db);
-        let args: Vec<String> = content.split_whitespace().map(String::from).collect();
-        let name_str = args.first().ok_or(ParserError::EmptyTag)?.clone();
-        let name = TagName::new(self.db, name_str); // Intern the tag name
-        let bits = args.into_iter().skip(1).collect();
-        let span = Span::from_token(&token, self.db);
+        let Token::Block {
+            content: content_ref,
+            ..
+        } = token
+        else {
+            return Err(ParserError::InvalidSyntax {
+                context: "Expected Block token".to_string(),
+            });
+        };
+
+        let mut parts = content_ref.text(self.db).split_whitespace();
+
+        let name_str = parts.next().ok_or(ParserError::EmptyTag)?;
+        let name = TagName::new(self.db, name_str.to_string());
+
+        let bits = parts.map(|s| TagBit::new(self.db, s.to_string())).collect();
+        let span = Span::from_token(token, self.db);
 
         Ok(Node::Tag { name, bits, span })
     }
 
-    fn parse_django_variable(&mut self) -> Result<Node<'db>, ParserError> {
+    fn parse_variable(&mut self) -> Result<Node<'db>, ParserError> {
         let token = self.peek_previous()?;
 
-        let content = token.content(self.db);
-        let bits: Vec<&str> = content.split('|').collect();
-        let var_str = bits
-            .first()
-            .ok_or(ParserError::EmptyTag)?
-            .trim()
-            .to_string();
-        let var = VariableName::new(self.db, var_str); // Intern the variable name
-        let filters = bits
-            .into_iter()
-            .skip(1)
-            .map(|s| FilterName::new(self.db, s.trim().to_string())) // Intern filter names
+        let Token::Variable {
+            content: content_ref,
+            ..
+        } = token
+        else {
+            return Err(ParserError::InvalidSyntax {
+                context: "Expected Variable token".to_string(),
+            });
+        };
+
+        let mut parts = content_ref.text(self.db).split('|');
+
+        let var_str = parts.next().ok_or(ParserError::EmptyTag)?.trim();
+        let var = VariableName::new(self.db, var_str.to_string());
+
+        let filters: Vec<FilterName<'db>> = parts
+            .map(|s| {
+                let trimmed = s.trim();
+                FilterName::new(self.db, trimmed.to_string())
+            })
             .collect();
-        let span = Span::from_token(&token, self.db);
+        let span = Span::from_token(token, self.db);
 
         Ok(Node::Variable { var, filters, span })
     }
@@ -175,58 +186,34 @@ impl<'db> Parser<'db> {
         Ok(Node::Text { span })
     }
 
-    fn peek(&self) -> Result<Token<'db>, ParserError> {
-        self.peek_at(0)
-    }
-
-    #[allow(dead_code)]
-    fn peek_next(&self) -> Result<Token<'db>, ParserError> {
-        self.peek_at(1)
-    }
-
-    fn peek_previous(&self) -> Result<Token<'db>, ParserError> {
-        self.peek_at(-1)
-    }
-
-    #[allow(clippy::cast_sign_loss)]
-    fn peek_at(&self, offset: isize) -> Result<Token<'db>, ParserError> {
-        // Safely handle negative offsets
-        let index = if offset < 0 {
-            // Check if we would underflow
-            if self.current < offset.unsigned_abs() {
-                return Err(ParserError::stream_error(StreamError::BeforeStart));
+    #[inline]
+    fn peek(&self) -> Result<&Token<'db>, ParserError> {
+        self.tokens.get(self.current).ok_or_else(|| {
+            if self.tokens.is_empty() {
+                ParserError::stream_error(StreamError::Empty)
+            } else {
+                ParserError::stream_error(StreamError::AtEnd)
             }
-            self.current - offset.unsigned_abs()
-        } else {
-            // Safe addition since offset is positive
-            self.current + (offset as usize)
-        };
-
-        self.item_at(index)
+        })
     }
 
-    fn item_at(&self, index: usize) -> Result<Token<'db>, ParserError> {
-        if let Some(token) = self.tokens.get(index) {
-            Ok(token.clone())
-        } else {
-            let error = if self.tokens.is_empty() {
-                ParserError::stream_error(StreamError::Empty)
-            } else if index < self.current {
-                ParserError::stream_error(StreamError::AtBeginning)
-            } else if index >= self.tokens.len() {
-                ParserError::stream_error(StreamError::AtEnd)
-            } else {
-                ParserError::stream_error(StreamError::InvalidAccess)
-            };
-            Err(error)
+    #[inline]
+    fn peek_previous(&self) -> Result<&Token<'db>, ParserError> {
+        if self.current == 0 {
+            return Err(ParserError::stream_error(StreamError::BeforeStart));
         }
+        self.tokens
+            .get(self.current - 1)
+            .ok_or_else(|| ParserError::stream_error(StreamError::InvalidAccess))
     }
 
+    #[inline]
     fn is_at_end(&self) -> bool {
         self.current + 1 >= self.tokens.len()
     }
 
-    fn consume(&mut self) -> Result<Token<'db>, ParserError> {
+    #[inline]
+    fn consume(&mut self) -> Result<&Token<'db>, ParserError> {
         if self.is_at_end() {
             return Err(ParserError::stream_error(StreamError::AtEnd));
         }
@@ -234,15 +221,6 @@ impl<'db> Parser<'db> {
         self.peek_previous()
     }
 
-    #[allow(dead_code)]
-    fn backtrack(&mut self, steps: usize) -> Result<Token<'db>, ParserError> {
-        if self.current < steps {
-            return Err(ParserError::stream_error(StreamError::AtBeginning));
-        }
-        self.current -= steps;
-        self.peek_next()
-    }
-
     fn synchronize(&mut self) -> Result<(), ParserError> {
         while !self.is_at_end() {
             let current = self.peek()?;
@@ -381,8 +359,8 @@ mod tests {
     #[salsa::tracked]
     fn parse_test_template(db: &dyn TemplateDb, template: TestTemplate) -> NodeList<'_> {
         let source = template.source(db);
-        let tokens = Lexer::new(db, source).tokenize();
-        let token_stream = TokenStream::new(db, tokens);
+        let (tokens, line_offsets) = Lexer::new(db, source).tokenize();
+        let token_stream = TokenStream::new(db, tokens, line_offsets);
         let mut parser = Parser::new(db, token_stream);
         let (ast, _) = parser.parse().unwrap();
         ast
@@ -421,7 +399,7 @@ mod tests {
             match node {
                 Node::Tag { name, bits, span } => TestNode::Tag {
                     name: name.text(db).to_string(),
-                    bits: bits.clone(),
+                    bits: bits.iter().map(|b| b.text(db).to_string()).collect(),
                     span: (span.start, span.length),
                 },
                 Node::Comment { content, span } => TestNode::Comment {
diff --git a/crates/djls-templates/src/tokens.rs b/crates/djls-templates/src/tokens.rs
index 3ba27d5f..c0156313 100644
--- a/crates/djls-templates/src/tokens.rs
+++ b/crates/djls-templates/src/tokens.rs
@@ -1,3 +1,4 @@
+use crate::ast::LineOffsets;
 use crate::db::Db as TemplateDb;
 
 #[derive(Clone, Debug, PartialEq, Hash, salsa::Update)]
@@ -75,7 +76,7 @@ impl<'db> Token<'db> {
             | Token::Text { offset, .. }
             | Token::Variable { offset, .. }
             | Token::Whitespace { offset, .. } => {
-                Some(u32::try_from(*offset).expect("Offset should fit in u32"))
+                Some(u32::try_from(*offset).expect("Offset should fit in u33"))
             }
             Token::Eof { .. } => None,
         }
@@ -159,6 +160,9 @@ pub struct TokenStream<'db> {
     #[tracked]
     #[returns(ref)]
     pub stream: Vec<Token<'db>>,
+    #[tracked]
+    #[returns(ref)]
+    pub line_offsets: LineOffsets,
 }
 
 impl<'db> TokenStream<'db> {
diff --git a/crates/djls-templates/src/validation.rs b/crates/djls-templates/src/validation.rs
index b74235ec..ea128b2f 100644
--- a/crates/djls-templates/src/validation.rs
+++ b/crates/djls-templates/src/validation.rs
@@ -20,6 +20,7 @@
 use crate::ast::Node;
 use crate::ast::NodeListError;
 use crate::ast::Span;
+use crate::ast::TagBit;
 use crate::ast::TagName;
 use crate::db::Db as TemplateDb;
 use crate::templatetags::Arg;
@@ -104,7 +105,7 @@ impl<'db> TagValidator<'db> {
     fn check_arguments(
         &mut self,
         name: &str,
-        bits: &[String],
+        bits: &[TagBit<'db>],
         span: Span,
         args: Option<&Vec<Arg>>,
     ) {
@@ -169,7 +170,7 @@ impl<'db> TagValidator<'db> {
         }
     }
 
-    fn handle_closer(&mut self, name: TagName<'db>, bits: &[String], span: Span) {
+    fn handle_closer(&mut self, name: TagName<'db>, bits: &[TagBit<'db>], span: Span) {
         let name_str = name.text(self.db);
 
         if self.stack.is_empty() {
@@ -248,7 +249,7 @@ impl<'db> TagValidator<'db> {
             // Named closer with no matching named block
             // Report the mismatch
             self.errors.push(NodeListError::UnmatchedBlockName {
-                name: bits[0].clone(),
+                name: bits[0].text(self.db),
                 span,
             });
 
@@ -321,9 +322,10 @@ mod tests {
     use std::sync::Arc;
 
     use super::*;
+    use crate::lexer::Lexer;
+    use crate::parser::Parser;
     use crate::templatetags::TagSpecs;
-    use crate::Lexer;
-    use crate::Parser;
+    use crate::tokens::TokenStream;
 
     // Test database that implements the required traits
     #[salsa::db]
@@ -375,8 +377,8 @@ mod tests {
     #[salsa::tracked]
     fn parse_test_template(db: &dyn TemplateDb, source: TestSource) -> NodeList<'_> {
         let text = source.text(db);
-        let tokens = Lexer::new(db, text).tokenize();
-        let token_stream = crate::tokens::TokenStream::new(db, tokens);
+        let (tokens, line_offsets) = Lexer::new(db, text).tokenize();
+        let token_stream = TokenStream::new(db, tokens, line_offsets);
         let mut parser = Parser::new(db, token_stream);
         let (ast, _) = parser.parse().unwrap();
         ast