diff --git a/Cargo.lock b/Cargo.lock
index 6762fcfa1e3e..4e7876f6e42d 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -303,6 +303,12 @@ dependencies = [
  "simd-abstraction",
 ]
 
+[[package]]
+name = "beef"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3a8241f3ebb85c056b509d4327ad0358fbbba6ffb340bf388f26350aeda225b1"
+
 [[package]]
 name = "better_scoped_tls"
 version = "1.0.0"
@@ -1893,7 +1899,7 @@ checksum = "cdc6457c0eb62c71aac4bc17216026d8410337c4126773b9c5daba343f17964f"
 dependencies = [
  "atomic-polyfill",
  "hash32",
- "rustc_version 0.4.0",
+ "rustc_version 0.4.1",
  "spin",
  "stable_deref_trait",
 ]
@@ -2611,6 +2617,40 @@ version = "0.4.22"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a7a70ba024b9dc04c27ea2f0c0548feb474ec5c54bba33a7f72f873a39d07b24"
 
+[[package]]
+name = "logos"
+version = "0.15.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ab6f536c1af4c7cc81edf73da1f8029896e7e1e16a219ef09b184e76a296f3db"
+dependencies = [
+ "logos-derive",
+]
+
+[[package]]
+name = "logos-codegen"
+version = "0.15.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "189bbfd0b61330abea797e5e9276408f2edbe4f822d7ad08685d67419aafb34e"
+dependencies = [
+ "beef",
+ "fnv",
+ "lazy_static",
+ "proc-macro2",
+ "quote",
+ "regex-syntax 0.8.4",
+ "rustc_version 0.4.1",
+ "syn 2.0.87",
+]
+
+[[package]]
+name = "logos-derive"
+version = "0.15.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ebfe8e1a19049ddbfccbd14ac834b215e11b85b90bab0c2dba7c7b92fb5d5cba"
+dependencies = [
+ "logos-codegen",
+]
+
 [[package]]
 name = "lru"
 version = "0.10.1"
@@ -3786,9 +3826,9 @@ dependencies = [
 
 [[package]]
 name = "rustc_version"
-version = "0.4.0"
+version = "0.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bfa0f585226d2e68097d4f95d113b15b83a82e819ab25717ec0590d9584ef366"
+checksum = "cfcb3a22ef46e85b45de6ee7e79d063319ebb6594faafcf1c225ea92ab6e9b92"
 dependencies = [
  "semver 1.0.23",
 ]
@@ -5217,6 +5257,7 @@ dependencies = [
  "codspeed-criterion-compat",
  "criterion",
  "either",
+ "logos",
  "new_debug_unreachable",
  "num-bigint",
  "num-traits",
@@ -5230,6 +5271,7 @@ dependencies = [
  "swc_atoms",
  "swc_common",
  "swc_ecma_ast",
+ "swc_ecma_raw_lexer",
  "swc_ecma_visit",
  "swc_malloc",
  "testing",
@@ -5293,6 +5335,17 @@ dependencies = [
  "syn 2.0.87",
 ]
 
+[[package]]
+name = "swc_ecma_raw_lexer"
+version = "0.1.0"
+dependencies = [
+ "logos",
+ "new_debug_unreachable",
+ "pretty_assertions",
+ "regex",
+ "swc_common",
+]
+
 [[package]]
 name = "swc_ecma_testing"
 version = "5.0.0"
diff --git a/Cargo.toml b/Cargo.toml
index a5107594fbd3..cfe3f63e996c 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -58,6 +58,7 @@ resolver = "2"
   jsonc-parser              = "0.21.0"
   lazy_static               = "1.4.0"
   lexical                   = "6.1.0"
+  logos                     = "0.15.0"
   lru                       = "0.10.0"
   memchr                    = "2.6.1"
   miette                    = "7.2.0"
@@ -129,7 +130,7 @@ lto = true
 # We use CARGO_PROFILE_RELEASE_LTO for production builds
 # lto = "fat"
 
-# debug = true
+debug = true
 # opt-level = 'z'
 
 [profile.bench]
diff --git a/crates/swc_common/src/input.rs b/crates/swc_common/src/input.rs
index 52c325c6b705..c7565721dff3 100644
--- a/crates/swc_common/src/input.rs
+++ b/crates/swc_common/src/input.rs
@@ -40,7 +40,7 @@ impl<'a> StringInput<'a> {
     }
 
     #[inline(always)]
-    pub fn as_str(&self) -> &str {
+    pub fn as_str(&self) -> &'a str {
         self.iter.as_str()
     }
 
diff --git a/crates/swc_ecma_parser/Cargo.toml b/crates/swc_ecma_parser/Cargo.toml
index f4405098f25a..0a6168b5ea57 100644
--- a/crates/swc_ecma_parser/Cargo.toml
+++ b/crates/swc_ecma_parser/Cargo.toml
@@ -25,21 +25,23 @@ typescript    = []
 verify        = ["swc_ecma_visit"]
 
 [dependencies]
-either      = { workspace = true }
-num-bigint  = { workspace = true }
-num-traits  = { workspace = true }
-serde       = { workspace = true, features = ["derive"] }
-smallvec    = { workspace = true }
-smartstring = { workspace = true }
-tracing     = { workspace = true }
-typed-arena = { workspace = true }
-
+either                = { workspace = true }
+logos                 = { workspace = true }
 new_debug_unreachable = { workspace = true }
+num-bigint            = { workspace = true }
+num-traits            = { workspace = true }
 phf                   = { workspace = true, features = ["macros"] }
-swc_atoms             = { version = "3.0.2", path = "../swc_atoms" }
-swc_common            = { version = "5.0.0", path = "../swc_common" }
-swc_ecma_ast          = { version = "5.0.1", path = "../swc_ecma_ast" }
-swc_ecma_visit        = { version = "5.0.0", path = "../swc_ecma_visit", optional = true }
+serde                 = { workspace = true, features = ["derive"] }
+smallvec              = { workspace = true }
+smartstring           = { workspace = true }
+tracing               = { workspace = true }
+typed-arena           = { workspace = true }
+
+swc_atoms          = { version = "3.0.2", path = "../swc_atoms" }
+swc_common         = { version = "5.0.0", path = "../swc_common" }
+swc_ecma_ast       = { version = "5.0.1", path = "../swc_ecma_ast" }
+swc_ecma_raw_lexer = { version = "0.1.0", path = "../swc_ecma_raw_lexer" }
+swc_ecma_visit     = { version = "5.0.0", path = "../swc_ecma_visit", optional = true }
 
 [target.'cfg(not(any(target_arch = "wasm32", target_arch = "arm")))'.dependencies]
 stacker = { version = "0.1.15", optional = true }
diff --git a/crates/swc_ecma_parser/src/error.rs b/crates/swc_ecma_parser/src/error.rs
index 37ebffe5b5ea..f2e65b532d52 100644
--- a/crates/swc_ecma_parser/src/error.rs
+++ b/crates/swc_ecma_parser/src/error.rs
@@ -7,6 +7,7 @@ use swc_common::{
     errors::{DiagnosticBuilder, Handler},
     Span, Spanned,
 };
+use swc_ecma_raw_lexer::LogosError;
 
 use crate::token::Token;
 
@@ -292,6 +293,8 @@ pub enum SyntaxError {
 
     ReservedTypeAssertion,
     ReservedArrowTypeParam,
+
+    UnexpectedCharFromLexer,
 }
 
 impl SyntaxError {
@@ -758,6 +761,7 @@ impl SyntaxError {
                                                     as in `<T,>() => ...`."
                 .into(),
             SyntaxError::InvalidAssignTarget => "Invalid assignment target".into(),
+            SyntaxError::UnexpectedCharFromLexer => "Unexpected character".into(),
         }
     }
 }
@@ -800,3 +804,12 @@ impl Error {
 fn size_of_error() {
     assert_eq!(std::mem::size_of::<Error>(), 8);
 }
+
+impl From<LogosError> for SyntaxError {
+    fn from(e: LogosError) -> Self {
+        match e {
+            LogosError::UnterminatedStr => SyntaxError::UnterminatedStrLit,
+            LogosError::UnknownChar => SyntaxError::UnexpectedCharFromLexer,
+        }
+    }
+}
diff --git a/crates/swc_ecma_parser/src/lexer/jsx.rs b/crates/swc_ecma_parser/src/lexer/jsx.rs
index b3c8852773c1..50a1abed7e20 100644
--- a/crates/swc_ecma_parser/src/lexer/jsx.rs
+++ b/crates/swc_ecma_parser/src/lexer/jsx.rs
@@ -1,18 +1,18 @@
 use either::Either;
 use smartstring::{LazyCompact, SmartString};
+use swc_ecma_raw_lexer::RawToken;
 
 use super::*;
 
 impl Lexer<'_> {
-    pub(super) fn read_jsx_token(&mut self) -> LexResult<Option<Token>> {
+    pub(super) fn read_jsx_token(&mut self, start: &mut BytePos) -> LexResult<Option<Token>> {
         debug_assert!(self.syntax.jsx());
 
-        let start = self.input.cur_pos();
         let mut chunk_start = self.input.cur_pos();
         let mut value = String::new();
 
         loop {
-            let cur = match self.input.cur() {
+            let cur = match self.cur()? {
                 Some(c) => c,
                 None => {
                     let start = self.state.start;
@@ -22,25 +22,25 @@ impl Lexer<'_> {
             let cur_pos = self.input.cur_pos();
 
             match cur {
-                '<' if self.had_line_break_before_last() && self.is_str("<<<<<< ") => {
+                RawToken::ConflictMarker => {
                     let span = Span::new(cur_pos, cur_pos + BytePos(7));
 
                     self.emit_error_span(span, SyntaxError::TS1185);
-                    self.skip_line_comment(6);
-                    self.skip_space::<true>();
-                    return self.read_token();
+                    // Bump conflict marker
+                    self.input.next();
+
+                    *start = self.input.cur_pos();
+                    return self.try_read_token(start);
                 }
-                '<' | '{' => {
+                RawToken::LtOp | RawToken::LBrace => {
                     //
                     if cur_pos == self.state.start {
-                        if cur == '<' && self.state.is_expr_allowed {
-                            unsafe {
-                                // Safety: cur() was Some('<')
-                                self.input.bump();
-                            }
+                        if cur == RawToken::LtOp && self.state.is_expr_allowed {
+                            self.input.next();
                             return Ok(Some(Token::JSXTagStart));
                         }
-                        return self.read_token();
+                        *start = self.input.cur_pos();
+                        return self.try_read_token(start);
                     }
 
                     let value = if value.is_empty() {
@@ -61,38 +61,32 @@ impl Lexer<'_> {
                     let raw = {
                         let s = unsafe {
                             // Safety: We already checked for the range
-                            self.input.slice(start, cur_pos)
+                            self.input.slice(*start, cur_pos)
                         };
                         self.atoms.atom(s)
                     };
 
                     return Ok(Some(Token::JSXText { raw, value }));
                 }
-                '>' => {
+                RawToken::GtOp => {
                     self.emit_error(
                         cur_pos,
                         SyntaxError::UnexpectedTokenWithSuggestions {
                             candidate_list: vec!["`{'>'}`", "`&gt;`"],
                         },
                     );
-                    unsafe {
-                        // Safety: cur() was Some('>')
-                        self.input.bump()
-                    }
+                    self.input.next();
                 }
-                '}' => {
+                RawToken::RBrace => {
                     self.emit_error(
                         cur_pos,
                         SyntaxError::UnexpectedTokenWithSuggestions {
                             candidate_list: vec!["`{'}'}`", "`&rbrace;`"],
                         },
                     );
-                    unsafe {
-                        // Safety: cur() was Some('}')
-                        self.input.bump()
-                    }
+                    self.input.next();
                 }
-                '&' => {
+                RawToken::BitAndOp => {
                     value.push_str(unsafe {
                         // Safety: We already checked for the range
                         self.input.slice(chunk_start, cur_pos)
@@ -116,10 +110,7 @@ impl Lexer<'_> {
                         }
                         chunk_start = self.input.cur_pos();
                     } else {
-                        unsafe {
-                            // Safety: cur() was Some(c)
-                            self.input.bump()
-                        }
+                        self.input.next();
                     }
                 }
             }
@@ -149,23 +140,23 @@ impl Lexer<'_> {
 
         let mut s = SmartString::<LazyCompact>::default();
 
-        let c = self.input.cur();
-        debug_assert_eq!(c, Some('&'));
+        let c = self.cur()?;
+        debug_assert_eq!(c, Some(RawToken::BitAndOp));
         unsafe {
             // Safety: cur() was Some('&')
-            self.input.bump();
+            self.input.bump(1);
         }
 
         let start_pos = self.input.cur_pos();
 
         for _ in 0..10 {
-            let c = match self.input.cur() {
+            let c = match self.input.cur_char() {
                 Some(c) => c,
                 None => break,
             };
             unsafe {
                 // Safety: cur() was Some(c)
-                self.input.bump();
+                self.input.bump(1);
             }
 
             if c == ';' {
@@ -205,17 +196,11 @@ impl Lexer<'_> {
     ) -> LexResult<Either<&'static str, char>> {
         debug_assert!(self.syntax.jsx());
 
-        let ch = self.input.cur().unwrap();
-        unsafe {
-            // Safety: cur() was Some(ch)
-            self.input.bump();
-        }
+        let ch = self.input.cur_char().unwrap();
+        self.input.next();
 
-        let out = if ch == '\r' && self.input.cur() == Some('\n') {
-            unsafe {
-                // Safety: cur() was Some('\n')
-                self.input.bump();
-            }
+        let out = if ch == '\r' && self.input.cur_char() == Some('\n') {
+            self.input.next();
             Either::Left(if normalize_crlf { "\n" } else { "\r\n" })
         } else {
             Either::Right(ch)
@@ -227,157 +212,22 @@ impl Lexer<'_> {
         Ok(out)
     }
 
-    pub(super) fn read_jsx_str(&mut self, quote: char) -> LexResult<Token> {
+    pub(super) fn read_jsx_str(&mut self) -> LexResult<Token> {
         debug_assert!(self.syntax.jsx());
 
-        let start = self.input.cur_pos();
-
-        unsafe {
-            // Safety: cur() was Some(quote)
-            self.input.bump(); // `quote`
-        }
-
-        let mut out = String::new();
-        let mut chunk_start = self.input.cur_pos();
-
-        loop {
-            let ch = match self.input.cur() {
-                Some(c) => c,
-                None => {
-                    let start = self.state.start;
-                    self.emit_error(start, SyntaxError::UnterminatedStrLit);
-                    break;
-                }
-            };
-
-            let cur_pos = self.input.cur_pos();
-
-            if ch == '\\' {
-                let value = unsafe {
-                    // Safety: We already checked for the range
-                    self.input.slice(chunk_start, cur_pos)
-                };
-
-                out.push_str(value);
-                out.push('\\');
-
-                self.bump();
-
-                chunk_start = self.input.cur_pos();
-
-                continue;
-            }
-
-            if ch == quote {
-                break;
-            }
-
-            if ch == '&' {
-                let value = unsafe {
-                    // Safety: We already checked for the range
-                    self.input.slice(chunk_start, cur_pos)
-                };
+        let s = self.input.cur_slice();
+        let value = &s[1..s.len() - 1];
 
-                out.push_str(value);
-
-                let jsx_entity = self.read_jsx_entity()?;
-
-                out.push(jsx_entity.0);
-
-                chunk_start = self.input.cur_pos();
-            } else if ch.is_line_terminator() {
-                let value = unsafe {
-                    // Safety: We already checked for the range
-                    self.input.slice(chunk_start, cur_pos)
-                };
-
-                out.push_str(value);
-
-                match self.read_jsx_new_line(false)? {
-                    Either::Left(s) => {
-                        out.push_str(s);
-                    }
-                    Either::Right(c) => {
-                        out.push(c);
-                    }
-                }
-
-                chunk_start = cur_pos + BytePos(ch.len_utf8() as _);
-            } else {
-                unsafe {
-                    // Safety: cur() was Some(ch)
-                    self.input.bump();
-                }
-            }
-        }
-
-        let value = if out.is_empty() {
-            // Fast path: We don't need to allocate
-
-            let cur_pos = self.input.cur_pos();
-            let value = unsafe {
-                // Safety: We already checked for the range
-                self.input.slice(chunk_start, cur_pos)
-            };
-
-            self.atoms.atom(value)
-        } else {
-            let cur_pos = self.input.cur_pos();
-            let value = unsafe {
-                // Safety: We already checked for the range
-                self.input.slice(chunk_start, cur_pos)
-            };
-
-            out.push_str(value);
-
-            self.atoms.atom(out)
-        };
+        let raw = self.atoms.atom(s);
+        let value = self.atoms.atom(value);
 
         // it might be at the end of the file when
         // the string literal is unterminated
-        if self.input.peek_ahead().is_some() {
-            unsafe {
-                // Safety: We called peek_ahead() which means cur() was Some
-                self.input.bump();
-            }
+        if matches!(self.input.peek_ahead(), Ok(Some(..))) {
+            let _ = self.input.next();
         }
 
-        let end = self.input.cur_pos();
-        let raw = unsafe {
-            // Safety: Both of `start` and `end` are generated from `cur_pos()`
-            self.input.slice(start, end)
-        };
-
-        Ok(Token::Str {
-            value,
-            raw: self.atoms.atom(raw),
-        })
-    }
-
-    /// Read a JSX identifier (valid tag or attribute name).
-    ///
-    /// Optimized version since JSX identifiers can"t contain
-    /// escape characters and so can be read as single slice.
-    /// Also assumes that first character was already checked
-    /// by isIdentifierStart in readToken.
-    pub(super) fn read_jsx_word(&mut self) -> LexResult<Token> {
-        debug_assert!(self.syntax.jsx());
-        debug_assert!(self.input.cur().is_some());
-        debug_assert!(self.input.cur().unwrap().is_ident_start());
-
-        let mut first = true;
-        let slice = self.input.uncons_while(|c| {
-            if first {
-                first = false;
-                c.is_ident_start()
-            } else {
-                c.is_ident_part() || c == '-'
-            }
-        });
-
-        Ok(Token::JSXName {
-            name: self.atoms.atom(slice),
-        })
+        Ok(Token::Str { value, raw })
     }
 }
 
diff --git a/crates/swc_ecma_parser/src/lexer/mod.rs b/crates/swc_ecma_parser/src/lexer/mod.rs
index 31bb91f29d3a..dea85b459cc3 100644
--- a/crates/swc_ecma_parser/src/lexer/mod.rs
+++ b/crates/swc_ecma_parser/src/lexer/mod.rs
@@ -1,26 +1,21 @@
 //! ECMAScript lexer.
 
-use std::{cell::RefCell, char, iter::FusedIterator, mem::transmute, rc::Rc};
+use std::{cell::RefCell, char, iter::FusedIterator, rc::Rc};
 
-use either::Either::{Left, Right};
 use smallvec::{smallvec, SmallVec};
 use swc_atoms::{Atom, AtomStoreCell};
 use swc_common::{comments::Comments, input::StringInput, BytePos, Span};
-use swc_ecma_ast::{op, AssignOp, EsVersion, Ident};
+use swc_ecma_ast::{AssignOp, EsVersion};
+use swc_ecma_raw_lexer::{RawLexer, RawToken};
 
-use self::{
-    comments_buffer::CommentsBuffer,
-    state::State,
-    table::{ByteHandler, BYTE_HANDLERS},
-    util::*,
-};
+use self::{comments_buffer::CommentsBuffer, state::State, util::CharExt};
 pub use self::{
     input::Input,
     state::{TokenContext, TokenContexts},
 };
 use crate::{
     error::{Error, SyntaxError},
-    token::{BinOpToken, IdentLike, Token, Word},
+    token::{BinOpToken, IdentLike, Keyword, KnownIdent, Token, Word},
     Context, Syntax,
 };
 
@@ -30,11 +25,9 @@ pub mod input;
 mod jsx;
 mod number;
 mod state;
-mod table;
 #[cfg(test)]
 mod tests;
 pub mod util;
-mod whitespace;
 
 pub(crate) type LexResult<T> = Result<T, Error>;
 
@@ -121,7 +114,7 @@ pub struct Lexer<'a> {
     comments_buffer: Option<CommentsBuffer>,
 
     pub(crate) ctx: Context,
-    input: StringInput<'a>,
+    input: RawLexer<'a>,
     start_pos: BytePos,
 
     state: State,
@@ -151,7 +144,7 @@ impl<'a> Lexer<'a> {
             comments,
             comments_buffer: comments.is_some().then(CommentsBuffer::new),
             ctx: Default::default(),
-            input,
+            input: RawLexer::new(input),
             start_pos,
             state: State::new(syntax, start_pos),
             syntax,
@@ -175,268 +168,292 @@ impl<'a> Lexer<'a> {
         op(self, &mut buf)
     }
 
-    /// babel: `getTokenFromCode`
-    fn read_token(&mut self) -> LexResult<Option<Token>> {
-        let byte = match self.input.as_str().as_bytes().first() {
-            Some(&v) => v,
+    fn try_read_token(&mut self, start: &mut BytePos) -> LexResult<Option<Token>> {
+        let cur = match self.cur()? {
+            Some(cur) => cur,
             None => return Ok(None),
         };
 
-        let handler = unsafe { *(&BYTE_HANDLERS as *const ByteHandler).offset(byte as isize) };
-
-        match handler {
-            Some(handler) => handler(self),
-            None => {
-                let start = self.cur_pos();
-                self.input.bump_bytes(1);
-                self.error_span(
-                    pos_span(start),
-                    SyntaxError::UnexpectedChar { c: byte as _ },
-                )
-            }
-        }
-    }
-
-    /// `#`
-    fn read_token_number_sign(&mut self) -> LexResult<Option<Token>> {
-        debug_assert!(self.cur().is_some());
-
-        unsafe {
-            // Safety: cur() is Some('#')
-            self.input.bump(); // '#'
-        }
-
-        // `#` can also be a part of shebangs, however they should have been
-        // handled by `read_shebang()`
-        debug_assert!(
-            !self.input.is_at_start() || self.cur() != Some('!'),
-            "#! should have already been handled by read_shebang()"
-        );
-        Ok(Some(Token::Hash))
+        self.read_token(cur, start)
     }
 
-    /// Read a token given `.`.
-    ///
-    /// This is extracted as a method to reduce size of `read_token`.
-    #[inline(never)]
-    fn read_token_dot(&mut self) -> LexResult<Token> {
-        // Check for eof
-        let next = match self.input.peek() {
-            Some(next) => next,
-            None => {
-                unsafe {
-                    // Safety: cur() is Some(',')
-                    self.input.bump();
+    /// babel: `getTokenFromCode`
+    fn read_token(&mut self, cur: RawToken, start: &mut BytePos) -> LexResult<Option<Token>> {
+        let token = match cur {
+            RawToken::LegacyCommentOpen | RawToken::LegacyCommentClose => {
+                // XML style comment. `<!--`
+                self.input.next();
+                self.emit_module_mode_error(*start, SyntaxError::LegacyCommentInModule);
+
+                *start = self.input.cur_pos();
+                return self.read_any_token(start);
+            }
+
+            RawToken::ConflictMarker => {
+                // All conflict markers consist of the same character repeated seven times.
+                // If it is a <<<<<<< or >>>>>>> marker then it is also followed by a space.
+                // <<<<<<<
+                //   ^
+                // >>>>>>>
+                //    ^
+
+                self.emit_error_span(fixed_len_span(*start, 7), SyntaxError::TS1185);
+                let _ = self.input.next();
+
+                *start = self.input.cur_pos();
+                return self.read_any_token(start);
+            }
+            RawToken::Arrow => Token::Arrow,
+            RawToken::Hash => Token::Hash,
+            RawToken::At => Token::At,
+            RawToken::Dot => Token::Dot,
+            RawToken::DotDotDot => Token::DotDotDot,
+            RawToken::Bang => Token::Bang,
+            RawToken::LParen => Token::LParen,
+            RawToken::RParen => Token::RParen,
+            RawToken::LBracket => Token::LBracket,
+            RawToken::RBracket => Token::RBracket,
+            RawToken::LBrace => Token::LBrace,
+            RawToken::RBrace => Token::RBrace,
+            RawToken::Semi => Token::Semi,
+            RawToken::Comma => Token::Comma,
+            RawToken::Colon => Token::Colon,
+            RawToken::BackQuote => Token::BackQuote,
+            RawToken::DollarLBrace => Token::DollarLBrace,
+            RawToken::QuestionMark => Token::QuestionMark,
+            RawToken::PlusPlus => Token::PlusPlus,
+            RawToken::MinusMinus => Token::MinusMinus,
+            RawToken::Tilde => Token::Tilde,
+            RawToken::Str => {
+                let s = self.input.cur_slice();
+                let value = &s[1..s.len() - 1];
+
+                Token::Str {
+                    value: self.atoms.atom(value),
+                    raw: self.atoms.atom(s),
                 }
-                return Ok(tok!('.'));
-            }
-        };
-        if next.is_ascii_digit() {
-            return self.read_number(true).map(|v| match v {
-                Left((value, raw)) => Token::Num { value, raw },
-                Right((value, raw)) => Token::BigInt { value, raw },
-            });
-        }
-
-        unsafe {
-            // Safety: cur() is Some
-            // 1st `.`
-            self.input.bump();
-        }
-
-        if next == '.' && self.input.peek() == Some('.') {
-            unsafe {
-                // Safety: peek() was Some
-
-                self.input.bump(); // 2nd `.`
-                self.input.bump(); // 3rd `.`
             }
+            RawToken::Num => {
+                let s = self.input.cur_slice();
+                let value = if let Some(s) = s.strip_prefix("0x").or_else(|| s.strip_prefix("0X")) {
+                    usize::from_str_radix(s, 16).unwrap() as f64
+                } else if let Some(s) = s.strip_prefix("0o").or_else(|| s.strip_prefix("0O")) {
+                    usize::from_str_radix(s, 8).unwrap() as f64
+                } else if let Some(s) = s.strip_prefix("0b").or_else(|| s.strip_prefix("0B")) {
+                    usize::from_str_radix(s, 2).unwrap() as f64
+                } else {
+                    s.parse::<f64>().unwrap_or_else(|_| {
+                        panic!("failed to parse number: {}", s);
+                    })
+                };
 
-            return Ok(tok!("..."));
-        }
-
-        Ok(tok!('.'))
-    }
-
-    /// Read a token given `?`.
-    ///
-    /// This is extracted as a method to reduce size of `read_token`.
-    #[inline(never)]
-    fn read_token_question_mark(&mut self) -> LexResult<Token> {
-        match self.input.peek() {
-            Some('?') => {
-                unsafe {
-                    // Safety: peek() was some
-                    self.input.bump();
-                    self.input.bump();
-                }
-                if self.input.cur() == Some('=') {
-                    unsafe {
-                        // Safety: cur() was some
-                        self.input.bump();
-                    }
-
-                    return Ok(tok!("??="));
-                }
-                Ok(tok!("??"))
-            }
-            _ => {
-                unsafe {
-                    // Safety: peek() is callable only if cur() is Some
-                    self.input.bump();
+                Token::Num {
+                    value,
+                    raw: self.atoms.atom(self.input.cur_slice()),
                 }
-                Ok(tok!('?'))
-            }
-        }
-    }
-
-    /// Read a token given `:`.
-    ///
-    /// This is extracted as a method to reduce size of `read_token`.
-    #[inline(never)]
-    fn read_token_colon(&mut self) -> LexResult<Token> {
-        unsafe {
-            // Safety: cur() is Some(':')
-            self.input.bump();
-        }
-        Ok(tok!(':'))
-    }
-
-    /// Read a token given `0`.
-    ///
-    /// This is extracted as a method to reduce size of `read_token`.
-    #[inline(never)]
-    fn read_token_zero(&mut self) -> LexResult<Token> {
-        let next = self.input.peek();
-
-        let bigint = match next {
-            Some('x') | Some('X') => self.read_radix_number::<16>(),
-            Some('o') | Some('O') => self.read_radix_number::<8>(),
-            Some('b') | Some('B') => self.read_radix_number::<2>(),
-            _ => {
-                return self.read_number(false).map(|v| match v {
-                    Left((value, raw)) => Token::Num { value, raw },
-                    Right((value, raw)) => Token::BigInt { value, raw },
-                });
-            }
-        };
-
-        bigint.map(|v| match v {
-            Left((value, raw)) => Token::Num { value, raw },
-            Right((value, raw)) => Token::BigInt { value, raw },
-        })
-    }
-
-    /// Read a token given `|` or `&`.
-    ///
-    /// This is extracted as a method to reduce size of `read_token`.
-    #[inline(never)]
-    fn read_token_logical(&mut self, c: u8) -> LexResult<Token> {
-        let had_line_break_before_last = self.had_line_break_before_last();
-        let start = self.cur_pos();
-
-        unsafe {
-            // Safety: cur() is Some(c as char)
-            self.input.bump();
-        }
-        let token = if c == b'&' {
-            BinOpToken::BitAnd
-        } else {
-            BinOpToken::BitOr
-        };
-
-        // '|=', '&='
-        if self.input.eat_byte(b'=') {
-            return Ok(Token::AssignOp(match token {
-                BinOpToken::BitAnd => AssignOp::BitAndAssign,
-                BinOpToken::BitOr => AssignOp::BitOrAssign,
-                _ => unreachable!(),
-            }));
-        }
-
-        // '||', '&&'
-        if self.input.cur() == Some(c as char) {
-            unsafe {
-                // Safety: cur() is Some(c)
-                self.input.bump();
             }
+            RawToken::LegacyOctalNum => {
+                let s = self.input.cur_slice();
+                let value = usize::from_str_radix(s, 8).unwrap() as f64;
 
-            if self.input.cur() == Some('=') {
-                unsafe {
-                    // Safety: cur() is Some('=')
-                    self.input.bump();
+                Token::Num {
+                    value,
+                    raw: self.atoms.atom(s),
                 }
-                return Ok(Token::AssignOp(match token {
-                    BinOpToken::BitAnd => op!("&&="),
-                    BinOpToken::BitOr => op!("||="),
-                    _ => unreachable!(),
-                }));
             }
+            RawToken::BigInt => Token::BigInt {
+                value: {
+                    let s = self.input.cur_slice();
+                    let s = s.strip_suffix("n").unwrap_or(s);
 
-            // |||||||
-            //   ^
-            if had_line_break_before_last && token == BinOpToken::BitOr && self.is_str("||||| ") {
-                let span = fixed_len_span(start, 7);
-                self.emit_error_span(span, SyntaxError::TS1185);
-                self.skip_line_comment(5);
-                self.skip_space::<true>();
-                return self.error_span(span, SyntaxError::TS1185);
-            }
-
-            return Ok(Token::BinOp(match token {
-                BinOpToken::BitAnd => BinOpToken::LogicalAnd,
-                BinOpToken::BitOr => BinOpToken::LogicalOr,
-                _ => unreachable!(),
-            }));
-        }
-
-        Ok(Token::BinOp(token))
-    }
+                    s.parse().map(Box::new).unwrap()
+                },
+                raw: self.atoms.atom(self.input.cur_slice()),
+            },
 
-    /// Read a token given `*` or `%`.
-    ///
-    /// This is extracted as a method to reduce size of `read_token`.
-    #[inline(never)]
-    fn read_token_mul_mod(&mut self, c: u8) -> LexResult<Token> {
-        let is_mul = c == b'*';
-        unsafe {
-            // Safety: cur() is Some(c)
-            self.input.bump();
-        }
-        let mut token = if is_mul {
-            Token::BinOp(BinOpToken::Mul)
-        } else {
-            Token::BinOp(BinOpToken::Mod)
+            RawToken::Shebang => {
+                self.emit_error(*start, SyntaxError::UnexpectedCharFromLexer);
+                self.input.next();
+
+                return self.try_read_token(start);
+            }
+
+            RawToken::Null => Token::Word(Word::Null),
+            RawToken::True => Token::Word(Word::True),
+            RawToken::False => Token::Word(Word::False),
+            RawToken::EqEqOp => Token::BinOp(BinOpToken::EqEq),
+            RawToken::NotEqOp => Token::BinOp(BinOpToken::NotEq),
+            RawToken::EqEqEqOp => Token::BinOp(BinOpToken::EqEqEq),
+            RawToken::NotEqEqOp => Token::BinOp(BinOpToken::NotEqEq),
+            RawToken::LtOp => Token::BinOp(BinOpToken::Lt),
+            RawToken::LtEqOp => Token::BinOp(BinOpToken::LtEq),
+            RawToken::GtOp => Token::BinOp(BinOpToken::Gt),
+            RawToken::GtEqOp => Token::BinOp(BinOpToken::GtEq),
+            RawToken::LShiftOp => Token::BinOp(BinOpToken::LShift),
+            RawToken::RShiftOp => Token::BinOp(BinOpToken::RShift),
+            RawToken::ZeroFillRShiftOp => Token::BinOp(BinOpToken::ZeroFillRShift),
+            RawToken::AddOp => Token::BinOp(BinOpToken::Add),
+            RawToken::SubOp => Token::BinOp(BinOpToken::Sub),
+            RawToken::MulOp => Token::BinOp(BinOpToken::Mul),
+            RawToken::DivOp => Token::BinOp(BinOpToken::Div),
+            RawToken::ModOp => Token::BinOp(BinOpToken::Mod),
+            RawToken::BitOrOp => Token::BinOp(BinOpToken::BitOr),
+            RawToken::BitXorOp => Token::BinOp(BinOpToken::BitXor),
+            RawToken::BitAndOp => Token::BinOp(BinOpToken::BitAnd),
+            RawToken::ExpOp => Token::BinOp(BinOpToken::Exp),
+            RawToken::LogicalOrOp => Token::BinOp(BinOpToken::LogicalOr),
+            RawToken::LogicalAndOp => Token::BinOp(BinOpToken::LogicalAnd),
+            RawToken::NullishCoalescingOp => Token::BinOp(BinOpToken::NullishCoalescing),
+            RawToken::AssignOp => Token::AssignOp(AssignOp::Assign),
+            RawToken::AddAssignOp => Token::AssignOp(AssignOp::AddAssign),
+            RawToken::SubAssignOp => Token::AssignOp(AssignOp::SubAssign),
+            RawToken::MulAssignOp => Token::AssignOp(AssignOp::MulAssign),
+            RawToken::DivAssignOp => Token::AssignOp(AssignOp::DivAssign),
+            RawToken::ModAssignOp => Token::AssignOp(AssignOp::ModAssign),
+            RawToken::LShiftAssignOp => Token::AssignOp(AssignOp::LShiftAssign),
+            RawToken::RShiftAssignOp => Token::AssignOp(AssignOp::RShiftAssign),
+            RawToken::ZeroFillRShiftAssignOp => Token::AssignOp(AssignOp::ZeroFillRShiftAssign),
+            RawToken::BitOrAssignOp => Token::AssignOp(AssignOp::BitOrAssign),
+            RawToken::BitXorAssignOp => Token::AssignOp(AssignOp::BitXorAssign),
+            RawToken::BitAndAssignOp => Token::AssignOp(AssignOp::BitAndAssign),
+            RawToken::ExpAssignOp => Token::AssignOp(AssignOp::ExpAssign),
+            RawToken::AndAssignOp => Token::AssignOp(AssignOp::AndAssign),
+            RawToken::OrAssignOp => Token::AssignOp(AssignOp::OrAssign),
+            RawToken::NullishAssignOp => Token::AssignOp(AssignOp::NullishAssign),
+
+            RawToken::JsxTagStart => Token::JSXTagStart,
+            RawToken::JsxTagEnd => Token::JSXTagEnd,
+
+            RawToken::Ident => Token::Word(Word::Ident(IdentLike::Other({
+                self.atoms.atom(self.input.cur_slice())
+            }))),
+            RawToken::NewLine | RawToken::Whitespace => {
+                let _ = self.input.next();
+                // self.skip_space::<true>();
+
+                *start = self.input.cur_pos();
+                return self.read_any_token(start);
+            }
+            RawToken::LineComment | RawToken::BlockComment => {
+                let _ = self.input.next();
+                // self.skip_space::<true>()?;
+
+                *start = self.input.cur_pos();
+                return self.read_any_token(start);
+            }
+            RawToken::Await => Token::Word(Word::Keyword(Keyword::Await)),
+            RawToken::Break => Token::Word(Word::Keyword(Keyword::Break)),
+            RawToken::Case => Token::Word(Word::Keyword(Keyword::Case)),
+            RawToken::Catch => Token::Word(Word::Keyword(Keyword::Catch)),
+            RawToken::Continue => Token::Word(Word::Keyword(Keyword::Continue)),
+            RawToken::Debugger => Token::Word(Word::Keyword(Keyword::Debugger)),
+            RawToken::Default_ => Token::Word(Word::Keyword(Keyword::Default_)),
+            RawToken::Do => Token::Word(Word::Keyword(Keyword::Do)),
+            RawToken::Else => Token::Word(Word::Keyword(Keyword::Else)),
+            RawToken::Finally => Token::Word(Word::Keyword(Keyword::Finally)),
+            RawToken::For => Token::Word(Word::Keyword(Keyword::For)),
+            RawToken::Function => Token::Word(Word::Keyword(Keyword::Function)),
+            RawToken::If => Token::Word(Word::Keyword(Keyword::If)),
+            RawToken::Return => Token::Word(Word::Keyword(Keyword::Return)),
+            RawToken::Switch => Token::Word(Word::Keyword(Keyword::Switch)),
+            RawToken::Throw => Token::Word(Word::Keyword(Keyword::Throw)),
+            RawToken::Try => Token::Word(Word::Keyword(Keyword::Try)),
+            RawToken::Var => Token::Word(Word::Keyword(Keyword::Var)),
+            RawToken::Let => Token::Word(Word::Keyword(Keyword::Let)),
+            RawToken::Const => Token::Word(Word::Keyword(Keyword::Const)),
+            RawToken::While => Token::Word(Word::Keyword(Keyword::While)),
+            RawToken::With => Token::Word(Word::Keyword(Keyword::With)),
+            RawToken::New => Token::Word(Word::Keyword(Keyword::New)),
+            RawToken::This => Token::Word(Word::Keyword(Keyword::This)),
+            RawToken::Super => Token::Word(Word::Keyword(Keyword::Super)),
+            RawToken::Class => Token::Word(Word::Keyword(Keyword::Class)),
+            RawToken::Extends => Token::Word(Word::Keyword(Keyword::Extends)),
+            RawToken::Export => Token::Word(Word::Keyword(Keyword::Export)),
+            RawToken::Import => Token::Word(Word::Keyword(Keyword::Import)),
+            RawToken::Yield => Token::Word(Word::Keyword(Keyword::Yield)),
+            RawToken::In => Token::Word(Word::Keyword(Keyword::In)),
+            RawToken::InstanceOf => Token::Word(Word::Keyword(Keyword::InstanceOf)),
+            RawToken::TypeOf => Token::Word(Word::Keyword(Keyword::TypeOf)),
+            RawToken::Void => Token::Word(Word::Keyword(Keyword::Void)),
+            RawToken::Delete => Token::Word(Word::Keyword(Keyword::Delete)),
+            RawToken::Abstract => Token::Word(Word::Ident(IdentLike::Known(KnownIdent::Abstract))),
+            RawToken::As => Token::Word(Word::Ident(IdentLike::Known(KnownIdent::As))),
+            RawToken::Async => Token::Word(Word::Ident(IdentLike::Known(KnownIdent::Async))),
+            RawToken::From => Token::Word(Word::Ident(IdentLike::Known(KnownIdent::From))),
+            RawToken::Of => Token::Word(Word::Ident(IdentLike::Known(KnownIdent::Of))),
+            RawToken::Type => Token::Word(Word::Ident(IdentLike::Known(KnownIdent::Type))),
+            RawToken::Global => Token::Word(Word::Ident(IdentLike::Known(KnownIdent::Global))),
+            RawToken::Static => Token::Word(Word::Ident(IdentLike::Known(KnownIdent::Static))),
+            RawToken::Using => Token::Word(Word::Ident(IdentLike::Known(KnownIdent::Using))),
+            RawToken::Readonly => Token::Word(Word::Ident(IdentLike::Known(KnownIdent::Readonly))),
+            RawToken::Unique => Token::Word(Word::Ident(IdentLike::Known(KnownIdent::Unique))),
+            RawToken::Keyof => Token::Word(Word::Ident(IdentLike::Known(KnownIdent::Keyof))),
+            RawToken::Declare => Token::Word(Word::Ident(IdentLike::Known(KnownIdent::Declare))),
+            RawToken::Enum => Token::Word(Word::Ident(IdentLike::Known(KnownIdent::Enum))),
+            RawToken::Is => Token::Word(Word::Ident(IdentLike::Known(KnownIdent::Is))),
+            RawToken::Infer => Token::Word(Word::Ident(IdentLike::Known(KnownIdent::Infer))),
+            RawToken::Symbol => Token::Word(Word::Ident(IdentLike::Known(KnownIdent::Symbol))),
+            RawToken::Undefined => {
+                Token::Word(Word::Ident(IdentLike::Known(KnownIdent::Undefined)))
+            }
+            RawToken::Interface => {
+                Token::Word(Word::Ident(IdentLike::Known(KnownIdent::Interface)))
+            }
+            RawToken::Implements => {
+                Token::Word(Word::Ident(IdentLike::Known(KnownIdent::Implements)))
+            }
+            RawToken::Asserts => Token::Word(Word::Ident(IdentLike::Known(KnownIdent::Asserts))),
+            RawToken::Require => Token::Word(Word::Ident(IdentLike::Known(KnownIdent::Require))),
+            RawToken::Get => Token::Word(Word::Ident(IdentLike::Known(KnownIdent::Get))),
+            RawToken::Set => Token::Word(Word::Ident(IdentLike::Known(KnownIdent::Set))),
+            RawToken::Any => Token::Word(Word::Ident(IdentLike::Known(KnownIdent::Any))),
+            RawToken::Intrinsic => {
+                Token::Word(Word::Ident(IdentLike::Known(KnownIdent::Intrinsic)))
+            }
+            RawToken::Unknown => Token::Word(Word::Ident(IdentLike::Known(KnownIdent::Unknown))),
+            RawToken::String => Token::Word(Word::Ident(IdentLike::Known(KnownIdent::String))),
+            RawToken::Object => Token::Word(Word::Ident(IdentLike::Known(KnownIdent::Object))),
+            RawToken::Number => Token::Word(Word::Ident(IdentLike::Known(KnownIdent::Number))),
+            RawToken::Bigint => Token::Word(Word::Ident(IdentLike::Known(KnownIdent::Bigint))),
+            RawToken::Boolean => Token::Word(Word::Ident(IdentLike::Known(KnownIdent::Boolean))),
+            RawToken::Never => Token::Word(Word::Ident(IdentLike::Known(KnownIdent::Never))),
+            RawToken::Assert => Token::Word(Word::Ident(IdentLike::Known(KnownIdent::Assert))),
+            RawToken::Namespace => {
+                Token::Word(Word::Ident(IdentLike::Known(KnownIdent::Namespace)))
+            }
+            RawToken::Accessor => Token::Word(Word::Ident(IdentLike::Known(KnownIdent::Accessor))),
+            RawToken::Meta => Token::Word(Word::Ident(IdentLike::Known(KnownIdent::Meta))),
+            RawToken::Target => Token::Word(Word::Ident(IdentLike::Known(KnownIdent::Target))),
+            RawToken::Satisfies => {
+                Token::Word(Word::Ident(IdentLike::Known(KnownIdent::Satisfies)))
+            }
+            RawToken::Package => Token::Word(Word::Ident(IdentLike::Known(KnownIdent::Package))),
+            RawToken::Protected => {
+                Token::Word(Word::Ident(IdentLike::Known(KnownIdent::Protected)))
+            }
+            RawToken::Private => Token::Word(Word::Ident(IdentLike::Known(KnownIdent::Private))),
+            RawToken::Public => Token::Word(Word::Ident(IdentLike::Known(KnownIdent::Public))),
         };
 
-        // check for **
-        if is_mul && self.input.eat_byte(b'*') {
-            token = Token::BinOp(BinOpToken::Exp)
-        }
+        // We skip whitespace tokens and newline tokens, so we need to update the
+        // start position.
+        *start = self.input.update_cur_pos();
+        let _ = self.input.next();
 
-        if self.input.eat_byte(b'=') {
-            token = match token {
-                Token::BinOp(BinOpToken::Mul) => Token::AssignOp(AssignOp::MulAssign),
-                Token::BinOp(BinOpToken::Mod) => Token::AssignOp(AssignOp::ModAssign),
-                Token::BinOp(BinOpToken::Exp) => Token::AssignOp(AssignOp::ExpAssign),
-                _ => unreachable!(),
-            }
-        }
-
-        Ok(token)
+        Ok(Some(token))
     }
 
     /// Read an escaped character for string literal.
     ///
     /// In template literal, we should preserve raw string.
     fn read_escaped_char(&mut self, in_template: bool) -> LexResult<Option<Vec<Char>>> {
-        debug_assert_eq!(self.cur(), Some('\\'));
+        debug_assert_eq!(self.input.cur_char(), Some('\\'));
 
-        let start = self.cur_pos();
+        let start = self.input.cur_pos();
 
         self.bump(); // '\'
 
-        let c = match self.cur() {
+        let c = match self.input.cur_char() {
             Some(c) => c,
             None => self.error_span(pos_span(start), SyntaxError::InvalidStrEscape)?,
         };
@@ -458,7 +475,7 @@ impl<'a> Lexer<'a> {
             '\r' => {
                 self.bump(); // remove '\r'
 
-                self.eat(b'\n');
+                self.input.eat(RawToken::NewLine);
 
                 return Ok(None);
             }
@@ -494,7 +511,7 @@ impl<'a> Lexer<'a> {
                 self.bump();
 
                 let first_c = if c == '0' {
-                    match self.cur() {
+                    match self.input.cur_char() {
                         Some(next) if next.is_digit(8) => c,
                         // \0 is not an octal literal nor decimal literal.
                         _ => return Ok(Some(vec!['\u{0000}'.into()])),
@@ -514,7 +531,7 @@ impl<'a> Lexer<'a> {
 
                 macro_rules! one {
                     ($check:expr) => {{
-                        let cur = self.cur();
+                        let cur = self.input.cur_char();
 
                         match cur.and_then(|c| c.to_digit(8)) {
                             Some(v) => {
@@ -545,380 +562,22 @@ impl<'a> Lexer<'a> {
             _ => c,
         };
 
-        unsafe {
-            // Safety: cur() is Some(c) if this method is called.
-            self.input.bump();
-        }
+        self.bump();
 
         Ok(Some(vec![c.into()]))
     }
-
-    fn read_token_plus_minus(&mut self, c: u8) -> LexResult<Option<Token>> {
-        let start = self.cur_pos();
-
-        unsafe {
-            // Safety: cur() is Some(c), if this method is called.
-            self.input.bump();
-        }
-
-        // '++', '--'
-        Ok(Some(if self.input.cur() == Some(c as char) {
-            unsafe {
-                // Safety: cur() is Some(c)
-                self.input.bump();
-            }
-
-            // Handle -->
-            if self.state.had_line_break && c == b'-' && self.eat(b'>') {
-                self.emit_module_mode_error(start, SyntaxError::LegacyCommentInModule);
-                self.skip_line_comment(0);
-                self.skip_space::<true>();
-                return self.read_token();
-            }
-
-            if c == b'+' {
-                Token::PlusPlus
-            } else {
-                Token::MinusMinus
-            }
-        } else if self.input.eat_byte(b'=') {
-            Token::AssignOp(if c == b'+' {
-                AssignOp::AddAssign
-            } else {
-                AssignOp::SubAssign
-            })
-        } else {
-            Token::BinOp(if c == b'+' {
-                BinOpToken::Add
-            } else {
-                BinOpToken::Sub
-            })
-        }))
-    }
-
-    fn read_token_bang_or_eq(&mut self, c: u8) -> LexResult<Option<Token>> {
-        let start = self.cur_pos();
-        let had_line_break_before_last = self.had_line_break_before_last();
-
-        unsafe {
-            // Safety: cur() is Some(c) if this method is called.
-            self.input.bump();
-        }
-
-        Ok(Some(if self.input.eat_byte(b'=') {
-            // "=="
-
-            if self.input.eat_byte(b'=') {
-                if c == b'!' {
-                    Token::BinOp(BinOpToken::NotEqEq)
-                } else {
-                    // =======
-                    //    ^
-                    if had_line_break_before_last && self.is_str("====") {
-                        self.emit_error_span(fixed_len_span(start, 7), SyntaxError::TS1185);
-                        self.skip_line_comment(4);
-                        self.skip_space::<true>();
-                        return self.read_token();
-                    }
-
-                    Token::BinOp(BinOpToken::EqEqEq)
-                }
-            } else if c == b'!' {
-                Token::BinOp(BinOpToken::NotEq)
-            } else {
-                Token::BinOp(BinOpToken::EqEq)
-            }
-        } else if c == b'=' && self.input.eat_byte(b'>') {
-            // "=>"
-
-            Token::Arrow
-        } else if c == b'!' {
-            Token::Bang
-        } else {
-            Token::AssignOp(AssignOp::Assign)
-        }))
-    }
 }
 
 impl Lexer<'_> {
-    #[inline(never)]
-    fn read_slash(&mut self) -> LexResult<Option<Token>> {
-        debug_assert_eq!(self.cur(), Some('/'));
-
-        // Divide operator
-        self.bump();
-
-        Ok(Some(if self.eat(b'=') {
-            tok!("/=")
-        } else {
-            tok!('/')
-        }))
-    }
-
-    #[inline(never)]
-    fn read_token_lt_gt(&mut self) -> LexResult<Option<Token>> {
-        debug_assert!(self.cur() == Some('<') || self.cur() == Some('>'));
-
-        let had_line_break_before_last = self.had_line_break_before_last();
-        let start = self.cur_pos();
-        let c = self.cur().unwrap();
-        self.bump();
-
-        if self.syntax.typescript() && self.ctx.in_type && !self.ctx.should_not_lex_lt_or_gt_as_type
-        {
-            if c == '<' {
-                return Ok(Some(tok!('<')));
-            } else if c == '>' {
-                return Ok(Some(tok!('>')));
-            }
-        }
-
-        // XML style comment. `<!--`
-        if c == '<' && self.is(b'!') && self.peek() == Some('-') && self.peek_ahead() == Some('-') {
-            self.skip_line_comment(3);
-            self.skip_space::<true>();
-            self.emit_module_mode_error(start, SyntaxError::LegacyCommentInModule);
-
-            return self.read_token();
-        }
-
-        let mut op = if c == '<' {
-            BinOpToken::Lt
-        } else {
-            BinOpToken::Gt
-        };
-
-        // '<<', '>>'
-        if self.cur() == Some(c) {
-            self.bump();
-            op = if c == '<' {
-                BinOpToken::LShift
-            } else {
-                BinOpToken::RShift
-            };
-
-            //'>>>'
-            if c == '>' && self.cur() == Some(c) {
-                self.bump();
-                op = BinOpToken::ZeroFillRShift;
-            }
-        }
-
-        let token = if self.eat(b'=') {
-            match op {
-                BinOpToken::Lt => Token::BinOp(BinOpToken::LtEq),
-                BinOpToken::Gt => Token::BinOp(BinOpToken::GtEq),
-                BinOpToken::LShift => Token::AssignOp(AssignOp::LShiftAssign),
-                BinOpToken::RShift => Token::AssignOp(AssignOp::RShiftAssign),
-                BinOpToken::ZeroFillRShift => Token::AssignOp(AssignOp::ZeroFillRShiftAssign),
-                _ => unreachable!(),
-            }
-        } else {
-            Token::BinOp(op)
-        };
-
-        // All conflict markers consist of the same character repeated seven times.
-        // If it is a <<<<<<< or >>>>>>> marker then it is also followed by a space.
-        // <<<<<<<
-        //   ^
-        // >>>>>>>
-        //    ^
-        if had_line_break_before_last
-            && match op {
-                BinOpToken::LShift if self.is_str("<<<<< ") => true,
-                BinOpToken::ZeroFillRShift if self.is_str(">>>> ") => true,
-                _ => false,
-            }
-        {
-            self.emit_error_span(fixed_len_span(start, 7), SyntaxError::TS1185);
-            self.skip_line_comment(5);
-            self.skip_space::<true>();
-            return self.read_token();
-        }
-
-        Ok(Some(token))
-    }
-
-    /// This can be used if there's no keyword starting with the first
-    /// character.
-    fn read_ident_unknown(&mut self) -> LexResult<Token> {
-        debug_assert!(self.cur().is_some());
-
-        let (word, _) = self
-            .read_word_as_str_with(|l, s, _, _| Word::Ident(IdentLike::Other(l.atoms.atom(s))))?;
-
-        Ok(Word(word))
-    }
-
-    /// This can be used if there's no keyword starting with the first
-    /// character.
-    fn read_word_with(
-        &mut self,
-        convert: &dyn Fn(&str) -> Option<Word>,
-    ) -> LexResult<Option<Token>> {
-        debug_assert!(self.cur().is_some());
-
-        let start = self.cur_pos();
-        let (word, has_escape) = self.read_word_as_str_with(|l, s, _, can_be_known| {
-            if can_be_known {
-                if let Some(word) = convert(s) {
-                    return word;
-                }
-            }
-
-            Word::Ident(IdentLike::Other(l.atoms.atom(s)))
-        })?;
-
-        // Note: ctx is store in lexer because of this error.
-        // 'await' and 'yield' may have semantic of reserved word, which means lexer
-        // should know context or parser should handle this error. Our approach to this
-        // problem is former one.
-        if has_escape && self.ctx.is_reserved(&word) {
-            self.error(
-                start,
-                SyntaxError::EscapeInReservedWord { word: word.into() },
-            )?
-        } else {
-            Ok(Some(Token::Word(word)))
-        }
-    }
-
-    /// This method is optimized for texts without escape sequences.
-    ///
-    /// `convert(text, has_escape, can_be_keyword)`
-    fn read_word_as_str_with<F, Ret>(&mut self, convert: F) -> LexResult<(Ret, bool)>
-    where
-        F: for<'any> FnOnce(&'any mut Lexer<'_>, &str, bool, bool) -> Ret,
-    {
-        debug_assert!(self.cur().is_some());
-        let mut first = true;
-        let mut can_be_keyword = true;
-        let mut slice_start = self.cur_pos();
-        let mut has_escape = false;
-
-        self.with_buf(|l, buf| {
-            loop {
-                if let Some(c) = l.input.cur_as_ascii() {
-                    // Performance optimization
-                    if can_be_keyword && (c.is_ascii_uppercase() || c.is_ascii_digit()) {
-                        can_be_keyword = false;
-                    }
-
-                    if Ident::is_valid_continue(c as _) {
-                        l.bump();
-                        continue;
-                    } else if first && Ident::is_valid_start(c as _) {
-                        l.bump();
-                        first = false;
-                        continue;
-                    }
-
-                    // unicode escape
-                    if c == b'\\' {
-                        first = false;
-                        has_escape = true;
-                        let start = l.cur_pos();
-                        l.bump();
-
-                        if !l.is(b'u') {
-                            l.error_span(pos_span(start), SyntaxError::ExpectedUnicodeEscape)?
-                        }
-
-                        {
-                            let end = l.input.cur_pos();
-                            let s = unsafe {
-                                // Safety: start and end are valid position because we got them from
-                                // `self.input`
-                                l.input.slice(slice_start, start)
-                            };
-                            buf.push_str(s);
-                            unsafe {
-                                // Safety: We got end from `self.input`
-                                l.input.reset_to(end);
-                            }
-                        }
-
-                        let chars = l.read_unicode_escape()?;
-
-                        if let Some(c) = chars.first() {
-                            let valid = if first {
-                                c.is_ident_start()
-                            } else {
-                                c.is_ident_part()
-                            };
-
-                            if !valid {
-                                l.emit_error(start, SyntaxError::InvalidIdentChar);
-                            }
-                        }
-
-                        for c in chars {
-                            buf.extend(c);
-                        }
-
-                        slice_start = l.cur_pos();
-                        continue;
-                    }
-
-                    // ASCII but not a valid identifier
-
-                    break;
-                }
-
-                if let Some(c) = l.input.cur() {
-                    if Ident::is_valid_continue(c) {
-                        l.bump();
-                        continue;
-                    } else if first && Ident::is_valid_start(c) {
-                        l.bump();
-                        first = false;
-                        continue;
-                    }
-                }
-
-                break;
-            }
-
-            let end = l.cur_pos();
-
-            let value = if !has_escape {
-                // Fast path: raw slice is enough if there's no escape.
-
-                let s = unsafe {
-                    // Safety: slice_start and end are valid position because we got them from
-                    // `self.input`
-                    l.input.slice(slice_start, end)
-                };
-                let s = unsafe {
-                    // Safety: We don't use 'static. We just bypass the lifetime check.
-                    transmute::<&str, &'static str>(s)
-                };
-
-                convert(l, s, has_escape, can_be_keyword)
-            } else {
-                let s = unsafe {
-                    // Safety: slice_start and end are valid position because we got them from
-                    // `self.input`
-                    l.input.slice(slice_start, end)
-                };
-                buf.push_str(s);
-
-                convert(l, buf, has_escape, can_be_keyword)
-            };
-
-            Ok((value, has_escape))
-        })
-    }
-
     fn read_unicode_escape(&mut self) -> LexResult<Vec<Char>> {
-        debug_assert_eq!(self.cur(), Some('u'));
+        debug_assert_eq!(self.input.cur_char(), Some('u'));
 
         let mut chars = Vec::new();
         let mut is_curly = false;
 
         self.bump(); // 'u'
 
-        if self.eat(b'{') {
+        if self.input.eat_ascii(b'{') {
             is_curly = true;
         }
 
@@ -928,7 +587,7 @@ impl Lexer<'_> {
                 if 0x0010_ffff >= val {
                     char::from_u32(val)
                 } else {
-                    let start = self.cur_pos();
+                    let start = self.input.cur_pos();
 
                     self.error(
                         start,
@@ -943,7 +602,7 @@ impl Lexer<'_> {
                 }
             }
             _ => {
-                let start = self.cur_pos();
+                let start = self.input.cur_pos();
 
                 self.error(
                     start,
@@ -975,7 +634,7 @@ impl Lexer<'_> {
                     chars.push(Char::from('{'));
 
                     for _ in 0..6 {
-                        if let Some(c) = self.input.cur() {
+                        if let Some(c) = self.input.cur_char() {
                             if c == '}' {
                                 break;
                             }
@@ -991,7 +650,7 @@ impl Lexer<'_> {
                     chars.push(Char::from('}'));
                 } else {
                     for _ in 0..4 {
-                        if let Some(c) = self.input.cur() {
+                        if let Some(c) = self.input.cur_char() {
                             self.bump();
 
                             chars.push(Char::from(c));
@@ -1001,140 +660,13 @@ impl Lexer<'_> {
             }
         }
 
-        if is_curly && !self.eat(b'}') {
+        if is_curly && !self.input.eat_ascii(b'}') {
             self.error(state, SyntaxError::InvalidUnicodeEscape)?
         }
 
         Ok(chars)
     }
 
-    /// See https://tc39.github.io/ecma262/#sec-literals-string-literals
-    fn read_str_lit(&mut self) -> LexResult<Token> {
-        debug_assert!(self.cur() == Some('\'') || self.cur() == Some('"'));
-        let start = self.cur_pos();
-        let quote = self.cur().unwrap() as u8;
-
-        self.bump(); // '"'
-
-        let mut has_escape = false;
-        let mut slice_start = self.input.cur_pos();
-
-        self.with_buf(|l, buf| {
-            loop {
-                if let Some(c) = l.input.cur_as_ascii() {
-                    if c == quote {
-                        let value_end = l.cur_pos();
-
-                        let value = if !has_escape {
-                            let s = unsafe {
-                                // Safety: slice_start and value_end are valid position because we
-                                // got them from `self.input`
-                                l.input.slice(slice_start, value_end)
-                            };
-
-                            l.atoms.atom(s)
-                        } else {
-                            let s = unsafe {
-                                // Safety: slice_start and value_end are valid position because we
-                                // got them from `self.input`
-                                l.input.slice(slice_start, value_end)
-                            };
-                            buf.push_str(s);
-
-                            l.atoms.atom(&**buf)
-                        };
-
-                        unsafe {
-                            // Safety: cur is quote
-                            l.input.bump();
-                        }
-
-                        let end = l.cur_pos();
-
-                        let raw = unsafe {
-                            // Safety: start and end are valid position because we got them from
-                            // `self.input`
-                            l.input.slice(start, end)
-                        };
-                        let raw = l.atoms.atom(raw);
-
-                        return Ok(Token::Str { value, raw });
-                    }
-
-                    if c == b'\\' {
-                        has_escape = true;
-
-                        {
-                            let end = l.cur_pos();
-                            let s = unsafe {
-                                // Safety: start and end are valid position because we got them from
-                                // `self.input`
-                                l.input.slice(slice_start, end)
-                            };
-                            buf.push_str(s);
-                        }
-
-                        if let Some(chars) = l.read_escaped_char(false)? {
-                            for c in chars {
-                                buf.extend(c);
-                            }
-                        }
-
-                        slice_start = l.cur_pos();
-                        continue;
-                    }
-
-                    if (c as char).is_line_break() {
-                        break;
-                    }
-
-                    unsafe {
-                        // Safety: cur is a ascii character
-                        l.input.bump();
-                    }
-                    continue;
-                }
-
-                match l.input.cur() {
-                    Some(c) => {
-                        if c.is_line_break() {
-                            break;
-                        }
-                        unsafe {
-                            // Safety: cur is Some(c)
-                            l.input.bump();
-                        }
-                    }
-                    None => break,
-                }
-            }
-
-            {
-                let end = l.cur_pos();
-                let s = unsafe {
-                    // Safety: start and end are valid position because we got them from
-                    // `self.input`
-                    l.input.slice(slice_start, end)
-                };
-                buf.push_str(s);
-            }
-
-            l.emit_error(start, SyntaxError::UnterminatedStrLit);
-
-            let end = l.cur_pos();
-
-            let raw = unsafe {
-                // Safety: start and end are valid position because we got them from
-                // `self.input`
-                l.input.slice(start, end)
-            };
-            Ok(Token::Str {
-                value: l.atoms.atom(&*buf),
-                raw: l.atoms.atom(raw),
-            })
-        })
-    }
-
     /// Expects current char to be '/'
     fn read_regexp(&mut self, start: BytePos) -> LexResult<Token> {
         unsafe {
@@ -1142,69 +674,28 @@ impl Lexer<'_> {
             self.input.reset_to(start);
         }
 
-        debug_assert_eq!(self.cur(), Some('/'));
-
-        let start = self.cur_pos();
-
-        self.bump();
-
-        let (mut escaped, mut in_class) = (false, false);
-
-        let content = self.with_buf(|l, buf| {
-            while let Some(c) = l.cur() {
-                // This is ported from babel.
-                // Seems like regexp literal cannot contain linebreak.
-                if c.is_line_terminator() {
-                    let span = l.span(start);
-
-                    return Err(Error::new(span, SyntaxError::UnterminatedRegExp));
-                }
-
-                if escaped {
-                    escaped = false;
-                } else {
-                    match c {
-                        '[' => in_class = true,
-                        ']' if in_class => in_class = false,
-                        // Terminates content part of regex literal
-                        '/' if !in_class => break,
-                        _ => {}
-                    }
-
-                    escaped = c == '\\';
-                }
-
-                l.bump();
-                buf.push(c);
-            }
-
-            Ok(l.atoms.atom(&**buf))
+        let content = self.input.read_regexp().map_err(|err| {
+            let start = self.input.cur_pos();
+            let _ = self.input.next();
+            Error::new(self.span(start), SyntaxError::from(err))
         })?;
-
-        // input is terminated without following `/`
-        if !self.is(b'/') {
-            let span = self.span(start);
-
-            return Err(Error::new(span, SyntaxError::UnterminatedRegExp));
-        }
-
-        self.bump(); // '/'
+        let content = self.atoms.atom(content);
 
         // Spec says "It is a Syntax Error if IdentifierPart contains a Unicode escape
         // sequence." TODO: check for escape
 
         // Need to use `read_word` because '\uXXXX' sequences are allowed
         // here (don't ask).
-        // let flags_start = self.cur_pos();
+        // let flags_start = self.input.cur_pos();
         let flags = {
-            match self.cur() {
-                Some(c) if c.is_ident_start() => self
-                    .read_word_as_str_with(|l, s, _, _| l.atoms.atom(s))
-                    .map(Some),
-                _ => Ok(None),
+            if self.cur()? == Some(RawToken::Ident) {
+                let s: Atom = self.atoms.atom(self.input.cur_slice());
+                self.input.next();
+                Some(s)
+            } else {
+                None
             }
-        }?
-        .map(|(value, _)| value)
+        }
         .unwrap_or_default();
 
         Ok(Token::Regex(content, flags))
@@ -1212,21 +703,15 @@ impl Lexer<'_> {
 
     #[cold]
     fn read_shebang(&mut self) -> LexResult<Option<Atom>> {
-        if self.input.cur() != Some('#') || self.input.peek() != Some('!') {
+        if !self.input.eat(RawToken::Shebang) {
             return Ok(None);
         }
-        unsafe {
-            // Safety: cur() is Some('#')
-            self.input.bump();
-            // Safety: cur() is Some('!')
-            self.input.bump();
-        }
-        let s = self.input.uncons_while(|c| !c.is_line_terminator());
-        Ok(Some(self.atoms.atom(s)))
+
+        Ok(Some(self.atoms.atom(self.input.cur_slice())))
     }
 
     fn read_tmpl_token(&mut self, start_of_tpl: BytePos) -> LexResult<Token> {
-        let start = self.cur_pos();
+        let start = self.input.cur_pos();
 
         let mut cooked = Ok(String::new());
         let mut cooked_slice_start = start;
@@ -1235,7 +720,7 @@ impl Lexer<'_> {
         macro_rules! consume_cooked {
             () => {{
                 if let Ok(cooked) = &mut cooked {
-                    let last_pos = self.cur_pos();
+                    let last_pos = self.input.cur_pos();
                     cooked.push_str(unsafe {
                         // Safety: Both of start and last_pos are valid position because we got them
                         // from `self.input`
@@ -1245,9 +730,9 @@ impl Lexer<'_> {
             }};
         }
 
-        while let Some(c) = self.cur() {
-            if c == '`' || (c == '$' && self.peek() == Some('{')) {
-                if start == self.cur_pos() && self.state.last_was_tpl_element() {
+        while let Some(c) = self.input.cur_char() {
+            if c == '`' || (c == '$' && self.input.peek_char() == Some('{')) {
+                if start == self.input.cur_pos() && self.state.last_was_tpl_element() {
                     if c == '$' {
                         self.bump();
                         self.bump();
@@ -1260,7 +745,7 @@ impl Lexer<'_> {
 
                 // If we don't have any escape
                 let cooked = if cooked_slice_start == raw_slice_start {
-                    let last_pos = self.cur_pos();
+                    let last_pos = self.input.cur_pos();
                     let s = unsafe {
                         // Safety: Both of start and last_pos are valid position because we got them
                         // from `self.input`
@@ -1304,13 +789,13 @@ impl Lexer<'_> {
                     }
                 }
 
-                cooked_slice_start = self.cur_pos();
+                cooked_slice_start = self.input.cur_pos();
             } else if c.is_line_terminator() {
                 self.state.had_line_break = true;
 
                 consume_cooked!();
 
-                let c = if c == '\r' && self.peek() == Some('\n') {
+                let c = if c == '\r' && self.input.peek_char() == Some('\n') {
                     self.bump(); // '\r'
                     '\n'
                 } else {
@@ -1328,7 +813,7 @@ impl Lexer<'_> {
                 if let Ok(ref mut cooked) = cooked {
                     cooked.push(c);
                 }
-                cooked_slice_start = self.cur_pos();
+                cooked_slice_start = self.input.cur_pos();
             } else {
                 self.bump();
             }
@@ -1352,6 +837,18 @@ impl Lexer<'_> {
     pub fn set_next_regexp(&mut self, start: Option<BytePos>) {
         self.state.next_regexp = start;
     }
+
+    #[inline(never)]
+    fn cur(&mut self) -> LexResult<Option<RawToken>> {
+        match self.input.cur() {
+            Err(err) => {
+                let start = self.input.cur_pos();
+                let _ = self.input.next();
+                Err(Error::new(self.span(start), SyntaxError::from(err)))
+            }
+            Ok(v) => Ok(v),
+        }
+    }
 }
 
 fn pos_span(p: BytePos) -> Span {
diff --git a/crates/swc_ecma_parser/src/lexer/number.rs b/crates/swc_ecma_parser/src/lexer/number.rs
index 0a13ff969d46..90b23341a12e 100644
--- a/crates/swc_ecma_parser/src/lexer/number.rs
+++ b/crates/swc_ecma_parser/src/lexer/number.rs
@@ -33,29 +33,29 @@ impl Lexer<'_> {
         &mut self,
         starts_with_dot: bool,
     ) -> LexResult<Either<(f64, Atom), (Box<BigIntValue>, Atom)>> {
-        debug_assert!(self.cur().is_some());
+        debug_assert!(matches!(self.cur(), Ok(Some(..))));
 
         if starts_with_dot {
             debug_assert_eq!(
-                self.cur(),
+                self.input.cur_char(),
                 Some('.'),
                 "read_number(starts_with_dot = true) expects current char to be '.'"
             );
         }
 
-        let start = self.cur_pos();
+        let start = self.input.cur_pos();
 
         let val = if starts_with_dot {
             // first char is '.'
             0f64
         } else {
-            let starts_with_zero = self.cur().unwrap() == '0';
+            let starts_with_zero = self.input.cur_char() == Some('0');
 
             // Use read_number_no_dot to support long numbers.
             let (val, s, not_octal) = self.read_number_no_dot_as_str::<10>()?;
 
-            if self.eat(b'n') {
-                let end = self.cur_pos();
+            if self.input.eat_ascii(b'n') {
+                let end = self.input.cur_pos();
                 let raw = unsafe {
                     // Safety: We got both start and end position from `self.input`
                     self.input.slice(start, end)
@@ -77,10 +77,10 @@ impl Lexer<'_> {
                     // e.g. `0` is decimal (so it can be part of float)
                     //
                     // e.g. `000` is octal
-                    if start.0 != self.last_pos().0 - 1 {
+                    if start.0 != self.input.cur_pos().0 - 1 {
                         // `-1` is utf 8 length of `0`
 
-                        let end = self.cur_pos();
+                        let end = self.input.cur_pos();
                         let raw = unsafe {
                             // Safety: We got both start and end position from `self.input`
                             self.input.slice(start, end)
@@ -115,7 +115,7 @@ impl Lexer<'_> {
                                     panic!("failed to parse {} into float using BigInt", val_str)
                                 });
 
-                            let end = self.cur_pos();
+                            let end = self.input.cur_pos();
                             let raw = unsafe {
                                 // Safety: We got both start and end position from `self.input`
                                 self.input.slice(start, end)
@@ -140,19 +140,19 @@ impl Lexer<'_> {
         //  `0.a`, `08.a`, `102.a` are invalid.
         //
         // `.1.a`, `.1e-4.a` are valid,
-        if self.cur() == Some('.') {
+        if self.input.cur_char() == Some('.') {
             self.bump();
 
             if starts_with_dot {
-                debug_assert!(self.cur().is_some());
-                debug_assert!(self.cur().unwrap().is_ascii_digit());
+                debug_assert!(self.input.cur_char().is_some());
+                debug_assert!(self.input.cur_char().unwrap().is_ascii_digit());
             }
 
             // Read numbers after dot
             self.read_int::<10>(0)?;
 
             val = {
-                let end = self.cur_pos();
+                let end = self.input.cur_pos();
                 let raw = unsafe {
                     // Safety: We got both start and end position from `self.input`
                     self.input.slice(start, end)
@@ -175,14 +175,14 @@ impl Lexer<'_> {
         // 1e2 = 100
         // 1e+2 = 100
         // 1e-2 = 0.01
-        match self.cur() {
+        match self.input.cur_char() {
             Some('e') | Some('E') => {
                 self.bump();
 
-                let next = match self.cur() {
+                let next = match self.input.cur_char() {
                     Some(next) => next,
                     None => {
-                        let pos = self.cur_pos();
+                        let pos = self.input.cur_pos();
                         self.error(pos, SyntaxError::NumLitTerminatedWithExp)?
                     }
                 };
@@ -204,7 +204,7 @@ impl Lexer<'_> {
                         0.0
                     }
                 } else {
-                    let end = self.cur_pos();
+                    let end = self.input.cur_pos();
                     let raw = unsafe {
                         // Safety: We got both start and end position from `self.input`
                         self.input.slice(start, end)
@@ -224,7 +224,7 @@ impl Lexer<'_> {
 
         self.ensure_not_ident()?;
 
-        let end = self.cur_pos();
+        let end = self.input.cur_pos();
         let raw_str = unsafe {
             // Safety: We got both start and end position from `self.input`
             self.input.slice(start, end)
@@ -241,13 +241,13 @@ impl Lexer<'_> {
             "radix should be one of 2, 8, 16, but got {}",
             RADIX
         );
-        debug_assert_eq!(self.cur(), Some('0'));
+        debug_assert_eq!(self.input.cur_char(), Some('0'));
 
-        let start = self.cur_pos();
+        let start = self.input.cur_pos();
 
         self.bump();
 
-        match self.input.cur() {
+        match self.cur()? {
             Some(..) => {
                 self.bump();
             }
@@ -258,8 +258,8 @@ impl Lexer<'_> {
 
         let (val, s, _) = self.read_number_no_dot_as_str::<RADIX>()?;
 
-        if self.eat(b'n') {
-            let end = self.cur_pos();
+        if self.input.eat_ascii(b'n') {
+            let end = self.input.cur_pos();
             let raw = unsafe {
                 // Safety: We got both start and end position from `self.input`
                 self.input.slice(start, end)
@@ -273,7 +273,7 @@ impl Lexer<'_> {
 
         self.ensure_not_ident()?;
 
-        let end = self.cur_pos();
+        let end = self.input.cur_pos();
         let raw = unsafe {
             // Safety: We got both start and end position from `self.input`
             self.input.slice(start, end)
@@ -290,7 +290,7 @@ impl Lexer<'_> {
             "radix for read_number_no_dot should be one of 2, 8, 10, 16, but got {}",
             RADIX
         );
-        let start = self.cur_pos();
+        let start = self.input.cur_pos();
 
         let mut read_any = false;
 
@@ -321,7 +321,7 @@ impl Lexer<'_> {
             "radix for read_number_no_dot should be one of 2, 8, 10, 16, but got {}",
             RADIX
         );
-        let start = self.cur_pos();
+        let start = self.input.cur_pos();
 
         let mut non_octal = false;
         let mut read_any = false;
@@ -343,7 +343,7 @@ impl Lexer<'_> {
             self.error(start, SyntaxError::ExpectedDigit { radix: RADIX })?;
         }
 
-        let end = self.cur_pos();
+        let end = self.input.cur_pos();
         let raw = unsafe {
             // Safety: We got both start and end position from `self.input`
             self.input.slice(start, end)
@@ -359,9 +359,9 @@ impl Lexer<'_> {
 
     /// Ensure that ident cannot directly follow numbers.
     fn ensure_not_ident(&mut self) -> LexResult<()> {
-        match self.cur() {
+        match self.input.cur_char() {
             Some(c) if c.is_ident_start() => {
-                let span = pos_span(self.cur_pos());
+                let span = pos_span(self.input.cur_pos());
                 self.error_span(span, SyntaxError::IdentAfterNum)?
             }
             _ => Ok(()),
@@ -435,14 +435,18 @@ impl Lexer<'_> {
         );
 
         if cfg!(feature = "debug") {
-            trace!("read_digits(radix = {}), cur = {:?}", RADIX, self.cur());
+            trace!(
+                "read_digits(radix = {}), cur = {:?}",
+                RADIX,
+                self.input.cur()
+            );
         }
 
-        let start = self.cur_pos();
+        let start = self.input.cur_pos();
         let mut total: Ret = Default::default();
         let mut prev = None;
 
-        while let Some(c) = self.cur() {
+        while let Some(c) = self.input.cur_char() {
             if allow_num_separator && c == '_' {
                 let is_allowed = |c: Option<char>| {
                     if c.is_none() {
@@ -465,7 +469,7 @@ impl Lexer<'_> {
                     }
                 };
 
-                let next = self.input.peek();
+                let next = self.input.peek_char();
 
                 if !is_allowed(next) || is_forbidden(prev) || is_forbidden(next) {
                     self.emit_error(
@@ -477,7 +481,7 @@ impl Lexer<'_> {
                 // Ignore this _ character
                 unsafe {
                     // Safety: cur() returns Some(c) where c is a valid char
-                    self.input.bump();
+                    self.input.bump(1);
                 }
 
                 continue;
@@ -519,315 +523,356 @@ impl Lexer<'_> {
     }
 }
 
-#[cfg(test)]
-mod tests {
-    use std::panic;
-
-    use super::*;
-
-    fn lex<F, Ret>(s: &'static str, f: F) -> Ret
-    where
-        F: FnOnce(&mut Lexer<'_>) -> Ret,
-    {
-        crate::with_test_sess(s, |_, input| {
-            let mut l = Lexer::new(
-                Syntax::Es(Default::default()),
-                Default::default(),
-                input,
-                None,
-            );
-            let ret = f(&mut l);
-            assert_eq!(l.input.cur(), None);
-            Ok(ret)
-        })
-        .unwrap()
-    }
-
-    fn num(s: &'static str) -> (f64, Atom) {
-        lex(s, |l| {
-            l.read_number(s.starts_with('.')).unwrap().left().unwrap()
-        })
-    }
-
-    fn int<const RADIX: u8>(s: &'static str) -> u32 {
-        lex(s, |l| {
-            l.read_int_u32::<RADIX>(0)
-                .unwrap()
-                .expect("read_int returned None")
-        })
-    }
-
-    const LONG: &str = "1e10000000000000000000000000000000000000000\
-                        0000000000000000000000000000000000000000000000000000";
-    #[test]
-    fn num_inf() {
-        assert_eq!(num(LONG), (f64::INFINITY, LONG.into()));
-    }
-
-    /// Number >= 2^53
-    #[test]
-    fn num_big_exp() {
-        assert_eq!((1e30, "1e30".into()), num("1e30"));
-    }
-
-    #[test]
-    fn num_very_big_exp() {
-        const LARGE_POSITIVE_EXP: &str =
-            "1e100000000000000000000000000000000000000000000000000000000000000\
-             00000000000000000000000000000000000000000000000000000000000000000\
-             00000000000000000000000000000000000000000000000000000000000000000\
-             00000000000000000000000000000000000000000000000000000000000000000\
-             00000000000000000000000000000000000000000000000000000";
-        const LARGE_NEGATIVE_EXP: &str =
-            "1e-10000000000000000000000000000000000000000000000000000000000000\
-             00000000000000000000000000000000000000000000000000000000000000000\
-             00000000000000000000000000000000000000000000000000000000000000000\
-             00000000000000000000000000000000000000000000000000000000000000000\
-             000000000000000000000000000000000000000000000000000000";
-        const ZERO_WITH_LARGE_POSITIVE_EXP: &str =
-            "0e100000000000000000000000000000000000000000000000000000000000000\
-             00000000000000000000000000000000000000000000000000000000000000000\
-             00000000000000000000000000000000000000000000000000000000000000000\
-             00000000000000000000000000000000000000000000000000000000000000000\
-             00000000000000000000000000000000000000000000000000000";
-        const ZERO_WITH_LARGE_NEGATIVE_EXP: &str =
-            "0e-10000000000000000000000000000000000000000000000000000000000000\
-             00000000000000000000000000000000000000000000000000000000000000000\
-             00000000000000000000000000000000000000000000000000000000000000000\
-             00000000000000000000000000000000000000000000000000000000000000000\
-             000000000000000000000000000000000000000000000000000000";
-        const LARGE_MANTISSA_WITH_LARGE_NEGATIVE_EXP: &str =
-            "10000000000000000000000000000000000000000000000000000000000000\
-             00000000000000000000000000000000000000000000000000000000000000000\
-             00000000000000000000000000000000000000000000000000000000000000000\
-             00000000000000000000000000000000000000000000000000000000000000000\
-             000000000000000000000000000000000000000000000000000000\
-             e-100000000000000000000000000000000000000000000000000000000000000\
-             00000000000000000000000000000000000000000000000000000000000000000\
-             00000000000000000000000000000000000000000000000000000000000000000\
-             00000000000000000000000000000000000000000000000000000000000000000\
-             000000000000000000000000000000000000000000000000000000";
-
-        assert_eq!(
-            num(LARGE_POSITIVE_EXP),
-            (f64::INFINITY, LARGE_POSITIVE_EXP.into())
-        );
-        assert_eq!(num(LARGE_NEGATIVE_EXP), (0.0, LARGE_NEGATIVE_EXP.into()));
-        assert_eq!(
-            num(ZERO_WITH_LARGE_POSITIVE_EXP),
-            (0.0, ZERO_WITH_LARGE_POSITIVE_EXP.into())
-        );
-        assert_eq!(
-            num(ZERO_WITH_LARGE_NEGATIVE_EXP),
-            (0.0, ZERO_WITH_LARGE_NEGATIVE_EXP.into())
-        );
-        assert_eq!(
-            num(LARGE_MANTISSA_WITH_LARGE_NEGATIVE_EXP),
-            (0.0, LARGE_MANTISSA_WITH_LARGE_NEGATIVE_EXP.into())
-        );
-    }
-
-    #[test]
-    fn num_big_many_zero() {
-        assert_eq!(
-            (
-                1_000_000_000_000_000_000_000_000_000_000f64,
-                "1000000000000000000000000000000".into()
-            ),
-            num("1000000000000000000000000000000")
-        );
-        assert_eq!(
-            (3.402_823_466_385_288_6e38, "34028234663852886e22".into()),
-            num("34028234663852886e22"),
-        );
-    }
-
-    #[test]
-    fn big_number_with_fract() {
-        assert_eq!(
-            (77777777777777777.1f64, "77777777777777777.1".into()),
-            num("77777777777777777.1")
-        )
-    }
-
-    #[test]
-    fn issue_480() {
-        assert_eq!((9.09, "9.09".into()), num("9.09"))
-    }
-
-    #[test]
-    fn num_legacy_octal() {
-        assert_eq!((0o12 as f64, "0012".into()), num("0012"));
-        assert_eq!((10f64, "012".into()), num("012"));
-    }
-
-    #[test]
-    fn read_int_1() {
-        assert_eq!(60, int::<10>("60"));
-        assert_eq!(0o73, int::<8>("73"));
-    }
-
-    #[test]
-    fn read_int_short() {
-        assert_eq!(7, int::<10>("7"));
-        assert_eq!(10, int::<10>("10"));
-    }
-
-    #[test]
-    fn read_radix_number() {
-        assert_eq!(
-            (0o73 as f64, "0o73".into()),
-            lex("0o73", |l| l
-                .read_radix_number::<8>()
-                .unwrap()
-                .left()
-                .unwrap())
-        );
-    }
-
-    #[test]
-    fn read_num_sep() {
-        assert_eq!(1_000, int::<10>("1_000"));
-        assert_eq!(0xaebece, int::<16>("AE_BE_CE"));
-        assert_eq!(0b1010000110000101, int::<2>("1010_0001_1000_0101"));
-        assert_eq!(0o0666, int::<8>("0_6_6_6"));
-    }
-
-    #[test]
-    fn read_bigint() {
-        assert_eq!(
-            lex(
-                "10000000000000000000000000000000000000000000000000000n",
-                |l| l.read_number(false).unwrap().right().unwrap()
-            ),
-            (
-                Box::new(
-                    "10000000000000000000000000000000000000000000000000000"
-                        .parse::<BigIntValue>()
-                        .unwrap()
-                ),
-                Atom::from("10000000000000000000000000000000000000000000000000000n")
-            ),
-        );
-    }
-
-    #[test]
-    fn large_bin_number() {
-        const LONG: &str =
-            "0B11111111111111111111111111111111111111111111111101001010100000010111110001111111111";
-        const VERY_LARGE_BINARY_NUMBER: &str =
-            "0B1111111111111111111111111111111111111111111111111111111111111111\
-             111111111111111111111111111111111111111111111111111111111111111111\
-             111111111111111111111111111111111111111111111111111111111111111111\
-             111111111111111111111111111111111111111111111111111111111111111111\
-             111111111111111111111111111111111111111111111111111111111111111111\
-             111111111111111111111111111111111111111111111111111111111111111111\
-             111111111111111111111111111111111111111111111111111111111111111111\
-             111111111111111111111111111111111111111111111111111111111111111111\
-             111111111111111111111111111111111111111111111111111111111111111111\
-             111111111111111111111111111111111111111111111111111111111111111111\
-             111111111111111111111111111111111111111111111111111111111111111111\
-             111111111111111111111111111111111111111111111111111111111111111111\
-             111111111111111111111111111111111111111111111111111111111111111111\
-             111111111111111111111111111111111111111111111111111111111111111111\
-             111111111111111111111111111111111111111111111111111111111111111111\
-             0010111110001111111111";
-        assert_eq!(
-            lex(LONG, |l| l
-                .read_radix_number::<2>()
-                .unwrap()
-                .left()
-                .unwrap()),
-            (9.671_406_556_917_009e24, LONG.into())
-        );
-        assert_eq!(
-            lex(VERY_LARGE_BINARY_NUMBER, |l| l
-                .read_radix_number::<2>()
-                .unwrap()
-                .left()
-                .unwrap()),
-            (1.0972248137587377e304, VERY_LARGE_BINARY_NUMBER.into())
-        );
-    }
-
-    #[test]
-    fn large_float_number() {
-        const LONG: &str = "9.671406556917009e+24";
-
-        assert_eq!(num(LONG), (9.671_406_556_917_009e24, LONG.into()));
-    }
-
-    /// Valid even on strict mode.
-    const VALID_CASES: &[&str] = &[".0", "0.e-1", "0e8", ".8e1", "0.8e1", "1.18e1"];
-    const INVALID_CASES_ON_STRICT: &[&str] = &["08e1", "08.1", "08.8e1", "08", "01"];
-    const INVALID_CASES: &[&str] = &["01.8e1", "012e1", "00e1", "00.0"];
-
-    fn test_floats(strict: bool, success: bool, cases: &'static [&'static str]) {
-        for case in cases {
-            println!(
-                "Testing {} (when strict = {}); Expects success = {}",
-                case, strict, success
-            );
-            // lazy way to get expected values
-            let expected: f64 = (i64::from_str_radix(case, 8).map(|v| v as f64))
-                .or_else(|_| case.parse::<i64>().map(|v| v as f64))
-                .or_else(|_| case.parse::<f64>())
-                .unwrap_or_else(|err| {
-                    panic!(
-                        "failed to parse '{}' as float using str.parse(): {}",
-                        case, err
-                    )
-                });
-
-            let vec = panic::catch_unwind(|| {
-                crate::with_test_sess(case, |_, input| {
-                    let mut l = Lexer::new(Syntax::default(), Default::default(), input, None);
-                    l.ctx.strict = strict;
-                    Ok(l.map(|ts| ts.token).collect::<Vec<_>>())
-                })
-                .unwrap()
-            });
-
-            if success {
-                let vec = match vec {
-                    Ok(vec) => vec,
-                    Err(err) => panic::resume_unwind(err),
-                };
-
-                assert_eq!(vec.len(), 1);
-
-                let token = vec.into_iter().next().unwrap();
-                let value = match token {
-                    Token::Num { value, .. } => value,
-                    _ => {
-                        panic!("expected num token in test")
-                    }
-                };
-
-                assert_eq!(expected, value);
-            } else if let Ok(vec) = vec {
-                assert_ne!(
-                    vec![Token::Num {
-                        value: expected,
-                        raw: expected.to_string().into()
-                    }],
-                    vec
-                )
-            }
-        }
-    }
-
-    //    #[test]
-    //    fn strict_mode() {
-    //        test_floats(true, true, VALID_CASES);
-    //        test_floats(true, false, INVALID_CASES_ON_STRICT);
-    //        test_floats(true, false, INVALID_CASES);
-    //    }
-
-    #[test]
-    fn non_strict() {
-        test_floats(false, true, VALID_CASES);
-        test_floats(false, true, INVALID_CASES_ON_STRICT);
-        test_floats(false, false, INVALID_CASES);
-    }
-}
+// #[cfg(test)]
+// mod tests {
+//     use std::panic;
+
+//     use super::*;
+
+//     fn lex<F, Ret>(s: &'static str, f: F) -> Ret
+//     where
+//         F: FnOnce(&mut Lexer<'_>) -> Ret,
+//     {
+//         crate::with_test_sess(s, |_, input| {
+//             let mut l = Lexer::new(
+//                 Syntax::Es(Default::default()),
+//                 Default::default(),
+//                 input,
+//                 None,
+//             );
+//             let ret = f(&mut l);
+//             assert_eq!(l.input.cur_char(), None);
+//             Ok(ret)
+//         })
+//         .unwrap()
+//     }
+
+//     fn num(s: &'static str) -> (f64, Atom) {
+//         lex(s, |l| {
+//             l.read_number(s.starts_with('.')).unwrap().left().unwrap()
+//         })
+//     }
+
+//     fn int<const RADIX: u8>(s: &'static str) -> u32 {
+//         lex(s, |l| {
+//             l.read_int_u32::<RADIX>(0)
+//                 .unwrap()
+//                 .expect("read_int returned None")
+//         })
+//     }
+
+//     const LONG: &str = "1e10000000000000000000000000000000000000000\
+//                         
+// 0000000000000000000000000000000000000000000000000000";     #[test]
+//     fn num_inf() {
+//         assert_eq!(num(LONG), (f64::INFINITY, LONG.into()));
+//     }
+
+//     /// Number >= 2^53
+//     #[test]
+//     fn num_big_exp() {
+//         assert_eq!((1e30, "1e30".into()), num("1e30"));
+//     }
+
+//     #[test]
+//     fn num_very_big_exp() {
+//         const LARGE_POSITIVE_EXP: &str =
+//             
+// "1e100000000000000000000000000000000000000000000000000000000000000\
+//              
+// 00000000000000000000000000000000000000000000000000000000000000000\
+//              
+// 00000000000000000000000000000000000000000000000000000000000000000\
+//              
+// 00000000000000000000000000000000000000000000000000000000000000000\
+//              00000000000000000000000000000000000000000000000000000";
+//         const LARGE_NEGATIVE_EXP: &str =
+//             
+// "1e-10000000000000000000000000000000000000000000000000000000000000\
+//              
+// 00000000000000000000000000000000000000000000000000000000000000000\
+//              
+// 00000000000000000000000000000000000000000000000000000000000000000\
+//              
+// 00000000000000000000000000000000000000000000000000000000000000000\
+//              000000000000000000000000000000000000000000000000000000";
+//         const ZERO_WITH_LARGE_POSITIVE_EXP: &str =
+//             
+// "0e100000000000000000000000000000000000000000000000000000000000000\
+//              
+// 00000000000000000000000000000000000000000000000000000000000000000\
+//              
+// 00000000000000000000000000000000000000000000000000000000000000000\
+//              
+// 00000000000000000000000000000000000000000000000000000000000000000\
+//              00000000000000000000000000000000000000000000000000000";
+//         const ZERO_WITH_LARGE_NEGATIVE_EXP: &str =
+//             
+// "0e-10000000000000000000000000000000000000000000000000000000000000\
+//              
+// 00000000000000000000000000000000000000000000000000000000000000000\
+//              
+// 00000000000000000000000000000000000000000000000000000000000000000\
+//              
+// 00000000000000000000000000000000000000000000000000000000000000000\
+//              000000000000000000000000000000000000000000000000000000";
+//         const LARGE_MANTISSA_WITH_LARGE_NEGATIVE_EXP: &str =
+//             "10000000000000000000000000000000000000000000000000000000000000\
+//              
+// 00000000000000000000000000000000000000000000000000000000000000000\
+//              
+// 00000000000000000000000000000000000000000000000000000000000000000\
+//              
+// 00000000000000000000000000000000000000000000000000000000000000000\
+//              000000000000000000000000000000000000000000000000000000\
+//              
+// e-100000000000000000000000000000000000000000000000000000000000000\
+//              
+// 00000000000000000000000000000000000000000000000000000000000000000\
+//              
+// 00000000000000000000000000000000000000000000000000000000000000000\
+//              
+// 00000000000000000000000000000000000000000000000000000000000000000\
+//              000000000000000000000000000000000000000000000000000000";
+
+//         assert_eq!(
+//             num(LARGE_POSITIVE_EXP),
+//             (f64::INFINITY, LARGE_POSITIVE_EXP.into())
+//         );
+//         assert_eq!(num(LARGE_NEGATIVE_EXP), (0.0,
+// LARGE_NEGATIVE_EXP.into()));         assert_eq!(
+//             num(ZERO_WITH_LARGE_POSITIVE_EXP),
+//             (0.0, ZERO_WITH_LARGE_POSITIVE_EXP.into())
+//         );
+//         assert_eq!(
+//             num(ZERO_WITH_LARGE_NEGATIVE_EXP),
+//             (0.0, ZERO_WITH_LARGE_NEGATIVE_EXP.into())
+//         );
+//         assert_eq!(
+//             num(LARGE_MANTISSA_WITH_LARGE_NEGATIVE_EXP),
+//             (0.0, LARGE_MANTISSA_WITH_LARGE_NEGATIVE_EXP.into())
+//         );
+//     }
+
+//     #[test]
+//     fn num_big_many_zero() {
+//         assert_eq!(
+//             (
+//                 1_000_000_000_000_000_000_000_000_000_000f64,
+//                 "1000000000000000000000000000000".into()
+//             ),
+//             num("1000000000000000000000000000000")
+//         );
+//         assert_eq!(
+//             (3.402_823_466_385_288_6e38, "34028234663852886e22".into()),
+//             num("34028234663852886e22"),
+//         );
+//     }
+
+//     #[test]
+//     fn big_number_with_fract() {
+//         assert_eq!(
+//             (77777777777777777.1f64, "77777777777777777.1".into()),
+//             num("77777777777777777.1")
+//         )
+//     }
+
+//     #[test]
+//     fn issue_480() {
+//         assert_eq!((9.09, "9.09".into()), num("9.09"))
+//     }
+
+//     #[test]
+//     fn num_legacy_octal() {
+//         assert_eq!((0o12 as f64, "0012".into()), num("0012"));
+//         assert_eq!((10f64, "012".into()), num("012"));
+//     }
+
+//     #[test]
+//     fn read_int_1() {
+//         assert_eq!(60, int::<10>("60"));
+//         assert_eq!(0o73, int::<8>("73"));
+//     }
+
+//     #[test]
+//     fn read_int_short() {
+//         assert_eq!(7, int::<10>("7"));
+//         assert_eq!(10, int::<10>("10"));
+//     }
+
+//     #[test]
+//     fn read_radix_number() {
+//         assert_eq!(
+//             (0o73 as f64, "0o73".into()),
+//             lex("0o73", |l| l
+//                 .read_radix_number::<8>()
+//                 .unwrap()
+//                 .left()
+//                 .unwrap())
+//         );
+//     }
+
+//     #[test]
+//     fn read_num_sep() {
+//         assert_eq!(1_000, int::<10>("1_000"));
+//         assert_eq!(0xaebece, int::<16>("AE_BE_CE"));
+//         assert_eq!(0b1010000110000101, int::<2>("1010_0001_1000_0101"));
+//         assert_eq!(0o0666, int::<8>("0_6_6_6"));
+//     }
+
+//     #[test]
+//     fn read_bigint() {
+//         assert_eq!(
+//             lex(
+//                 "10000000000000000000000000000000000000000000000000000n",
+//                 |l| l.read_number(false).unwrap().right().unwrap()
+//             ),
+//             (
+//                 Box::new(
+//                     "10000000000000000000000000000000000000000000000000000"
+//                         .parse::<BigIntValue>()
+//                         .unwrap()
+//                 ),
+//                 
+// Atom::from("10000000000000000000000000000000000000000000000000000n")
+//             ),
+//         );
+//     }
+
+//     #[test]
+//     fn large_bin_number() {
+//         const LONG: &str =
+//             
+// "0B11111111111111111111111111111111111111111111111101001010100000010111110001111111111"
+// ;         const VERY_LARGE_BINARY_NUMBER: &str =
+//             
+// "0B1111111111111111111111111111111111111111111111111111111111111111\
+//              
+// 111111111111111111111111111111111111111111111111111111111111111111\
+//              
+// 111111111111111111111111111111111111111111111111111111111111111111\
+//              
+// 111111111111111111111111111111111111111111111111111111111111111111\
+//              
+// 111111111111111111111111111111111111111111111111111111111111111111\
+//              
+// 111111111111111111111111111111111111111111111111111111111111111111\
+//              
+// 111111111111111111111111111111111111111111111111111111111111111111\
+//              
+// 111111111111111111111111111111111111111111111111111111111111111111\
+//              
+// 111111111111111111111111111111111111111111111111111111111111111111\
+//              
+// 111111111111111111111111111111111111111111111111111111111111111111\
+//              
+// 111111111111111111111111111111111111111111111111111111111111111111\
+//              
+// 111111111111111111111111111111111111111111111111111111111111111111\
+//              
+// 111111111111111111111111111111111111111111111111111111111111111111\
+//              
+// 111111111111111111111111111111111111111111111111111111111111111111\
+//              
+// 111111111111111111111111111111111111111111111111111111111111111111\
+//              0010111110001111111111";
+//         assert_eq!(
+//             lex(LONG, |l| l
+//                 .read_radix_number::<2>()
+//                 .unwrap()
+//                 .left()
+//                 .unwrap()),
+//             (9.671_406_556_917_009e24, LONG.into())
+//         );
+//         assert_eq!(
+//             lex(VERY_LARGE_BINARY_NUMBER, |l| l
+//                 .read_radix_number::<2>()
+//                 .unwrap()
+//                 .left()
+//                 .unwrap()),
+//             (1.0972248137587377e304, VERY_LARGE_BINARY_NUMBER.into())
+//         );
+//     }
+
+//     #[test]
+//     fn large_float_number() {
+//         const LONG: &str = "9.671406556917009e+24";
+
+//         assert_eq!(num(LONG), (9.671_406_556_917_009e24, LONG.into()));
+//     }
+
+//     /// Valid even on strict mode.
+//     const VALID_CASES: &[&str] = &[".0", "0.e-1", "0e8", ".8e1", "0.8e1",
+// "1.18e1"];     const INVALID_CASES_ON_STRICT: &[&str] = &["08e1", "08.1",
+// "08.8e1", "08", "01"];     const INVALID_CASES: &[&str] = &["01.8e1",
+// "012e1", "00e1", "00.0"];
+
+//     fn test_floats(strict: bool, success: bool, cases: &'static [&'static
+// str]) {         for case in cases {
+//             println!(
+//                 "Testing {} (when strict = {}); Expects success = {}",
+//                 case, strict, success
+//             );
+//             // lazy way to get expected values
+//             let expected: f64 = (i64::from_str_radix(case, 8).map(|v| v as
+// f64))                 .or_else(|_| case.parse::<i64>().map(|v| v as f64))
+//                 .or_else(|_| case.parse::<f64>())
+//                 .unwrap_or_else(|err| {
+//                     panic!(
+//                         "failed to parse '{}' as float using str.parse():
+// {}",                         case, err
+//                     )
+//                 });
+
+//             let vec = panic::catch_unwind(|| {
+//                 crate::with_test_sess(case, |_, input| {
+//                     let mut l = Lexer::new(Syntax::default(),
+// Default::default(), input, None);                     l.ctx.strict = strict;
+//                     Ok(l.map(|ts| ts.token).collect::<Vec<_>>())
+//                 })
+//                 .unwrap()
+//             });
+
+//             if success {
+//                 let vec = match vec {
+//                     Ok(vec) => vec,
+//                     Err(err) => panic::resume_unwind(err),
+//                 };
+
+//                 assert_eq!(vec.len(), 1);
+
+//                 let token = vec.into_iter().next().unwrap();
+//                 let value = match token {
+//                     Token::Num { value, .. } => value,
+//                     _ => {
+//                         panic!("expected num token in test")
+//                     }
+//                 };
+
+//                 assert_eq!(expected, value);
+//             } else if let Ok(vec) = vec {
+//                 assert_ne!(
+//                     vec![Token::Num {
+//                         value: expected,
+//                         raw: expected.to_string().into()
+//                     }],
+//                     vec
+//                 )
+//             }
+//         }
+//     }
+
+//     //    #[test]
+//     //    fn strict_mode() {
+//     //        test_floats(true, true, VALID_CASES);
+//     //        test_floats(true, false, INVALID_CASES_ON_STRICT);
+//     //        test_floats(true, false, INVALID_CASES);
+//     //    }
+
+//     #[test]
+//     fn non_strict() {
+//         test_floats(false, true, VALID_CASES);
+//         test_floats(false, true, INVALID_CASES_ON_STRICT);
+//         test_floats(false, false, INVALID_CASES);
+//     }
+// }
diff --git a/crates/swc_ecma_parser/src/lexer/state.rs b/crates/swc_ecma_parser/src/lexer/state.rs
index c881a0bc8d07..4473f2eb110f 100644
--- a/crates/swc_ecma_parser/src/lexer/state.rs
+++ b/crates/swc_ecma_parser/src/lexer/state.rs
@@ -1,17 +1,17 @@
 use std::mem::take;
 
 use smallvec::{smallvec, SmallVec};
-use swc_common::{BytePos, Span};
+use swc_common::BytePos;
+use swc_ecma_raw_lexer::RawToken;
 use tracing::trace;
 
 use super::{
     comments_buffer::{BufferedComment, BufferedCommentKind},
-    Context, Input, Lexer,
+    Context, Lexer,
 };
 use crate::{
-    error::{Error, SyntaxError},
+    error::Error,
     input::Tokens,
-    lexer::util::CharExt,
     token::{BinOpToken, Keyword, Token, TokenAndSpan, TokenKind, WordKind},
     EsVersion, Syntax,
 };
@@ -260,14 +260,17 @@ impl Lexer<'_> {
         self.state.had_line_break = self.state.is_first;
         self.state.is_first = false;
 
-        // skip spaces before getting next character, if we are allowed to.
-        if self.state.can_skip_space() {
-            self.skip_space::<true>();
-            *start = self.input.cur_pos();
-        };
+        self.read_any_token(start)
+    }
+
+    pub(super) fn read_any_token(&mut self, start: &mut BytePos) -> Result<Option<Token>, Error> {
+        if let Some(TokenContext::Tpl {}) = self.state.context.current() {
+            let start = self.state.tpl_start;
+            return self.read_tmpl_token(start).map(Some);
+        }
 
-        match self.input.cur() {
-            Some(..) => {}
+        let c = match self.cur()? {
+            Some(v) => v,
             // End of input.
             None => {
                 self.consume_pending_comments();
@@ -275,6 +278,8 @@ impl Lexer<'_> {
                 return Ok(None);
             }
         };
+        dbg!(&c, start.0, self.input.cur_slice());
+        dbg!(&self.state.context.current());
 
         // println!(
         //     "\tContext: ({:?}) {:?}",
@@ -287,62 +292,38 @@ impl Lexer<'_> {
         if self.syntax.jsx() && !self.ctx.in_property_name && !self.ctx.in_type {
             //jsx
             if self.state.context.current() == Some(TokenContext::JSXExpr) {
-                return self.read_jsx_token();
+                return self.read_jsx_token(start);
             }
 
-            let c = self.cur();
-            if let Some(c) = c {
-                if self.state.context.current() == Some(TokenContext::JSXOpeningTag)
-                    || self.state.context.current() == Some(TokenContext::JSXClosingTag)
-                {
-                    if c.is_ident_start() {
-                        return self.read_jsx_word().map(Some);
-                    }
-
-                    if c == '>' {
-                        unsafe {
-                            // Safety: cur() is Some('>')
-                            self.input.bump();
-                        }
-                        return Ok(Some(Token::JSXTagEnd));
-                    }
-
-                    if (c == '\'' || c == '"')
-                        && self.state.context.current() == Some(TokenContext::JSXOpeningTag)
-                    {
-                        return self.read_jsx_str(c).map(Some);
-                    }
+            if self.state.context.current() == Some(TokenContext::JSXOpeningTag)
+                || self.state.context.current() == Some(TokenContext::JSXClosingTag)
+            {
+                if c == RawToken::Ident {
+                    let name = self.atoms.atom(self.input.cur_slice());
+                    let _ = self.input.next();
+                    return Ok(Some(Token::JSXName { name }));
                 }
 
-                if c == '<' && self.state.is_expr_allowed && self.input.peek() != Some('!') {
-                    let had_line_break_before_last = self.had_line_break_before_last();
-                    let cur_pos = self.input.cur_pos();
-
-                    unsafe {
-                        // Safety: cur() is Some('<')
-                        self.input.bump();
-                    }
-
-                    if had_line_break_before_last && self.is_str("<<<<<< ") {
-                        let span = Span::new(cur_pos, cur_pos + BytePos(7));
-
-                        self.emit_error_span(span, SyntaxError::TS1185);
-                        self.skip_line_comment(6);
-                        self.skip_space::<true>();
-                        return self.read_token();
-                    }
+                if c == RawToken::GtOp {
+                    let _ = self.input.next();
+                    return Ok(Some(Token::JSXTagEnd));
+                }
 
-                    return Ok(Some(Token::JSXTagStart));
+                if (c == RawToken::Str)
+                    && self.state.context.current() == Some(TokenContext::JSXOpeningTag)
+                {
+                    return self.read_jsx_str().map(Some);
                 }
             }
-        }
 
-        if let Some(TokenContext::Tpl {}) = self.state.context.current() {
-            let start = self.state.tpl_start;
-            return self.read_tmpl_token(start).map(Some);
+            if c == RawToken::LtOp && self.state.is_expr_allowed {
+                self.input.next();
+
+                return Ok(Some(Token::JSXTagStart));
+            }
         }
 
-        self.read_token()
+        self.read_token(c, start)
     }
 }
 
@@ -350,7 +331,7 @@ impl Iterator for Lexer<'_> {
     type Item = TokenAndSpan;
 
     fn next(&mut self) -> Option<Self::Item> {
-        let mut start = self.cur_pos();
+        let mut start = self.input.cur_pos();
 
         let res = self.next_token(&mut start);
 
@@ -372,7 +353,7 @@ impl Iterator for Lexer<'_> {
             }
 
             self.state.update(start, token.kind());
-            self.state.prev_hi = self.last_pos();
+            self.state.prev_hi = self.input.cur_pos();
             self.state.had_line_break_before_last = self.had_line_break_before_last();
         }
 
diff --git a/crates/swc_ecma_parser/src/lexer/table.rs b/crates/swc_ecma_parser/src/lexer/table.rs
deleted file mode 100644
index b190245b3f80..000000000000
--- a/crates/swc_ecma_parser/src/lexer/table.rs
+++ /dev/null
@@ -1,399 +0,0 @@
-//! Lookup table for byte handlers.
-//!
-//! Idea is taken from ratel.
-//!
-//! https://github.com/ratel-rust/ratel-core/blob/e55a1310ba69a3f5ce2a9a6eef643feced02ac08/ratel/src/lexer/mod.rs#L665
-
-use either::Either;
-use swc_common::input::Input;
-use swc_ecma_ast::AssignOp;
-
-use super::{pos_span, util::CharExt, LexResult, Lexer};
-use crate::{
-    error::SyntaxError,
-    token::{BinOpToken, IdentLike, Keyword, KnownIdent, Token, Word},
-};
-
-pub(super) type ByteHandler = Option<for<'aa> fn(&mut Lexer<'aa>) -> LexResult<Option<Token>>>;
-
-/// Lookup table mapping any incoming byte to a handler function defined below.
-pub(super) static BYTE_HANDLERS: [ByteHandler; 256] = [
-    //   0    1    2    3    4    5    6    7    8    9    A    B    C    D    E    F   //
-    EOF, ___, ___, ___, ___, ___, ___, ___, ___, ___, ___, ___, ___, ___, ___, ___, // 0
-    ___, ___, ___, ___, ___, ___, ___, ___, ___, ___, ___, ___, ___, ___, ___, ___, // 1
-    ___, EXL, QOT, HSH, IDN, PRC, AMP, QOT, PNO, PNC, ATR, PLS, COM, MIN, PRD, SLH, // 2
-    ZER, DIG, DIG, DIG, DIG, DIG, DIG, DIG, DIG, DIG, COL, SEM, LSS, EQL, MOR, QST, // 3
-    AT_, IDN, IDN, IDN, IDN, IDN, IDN, IDN, IDN, IDN, IDN, IDN, IDN, IDN, IDN, IDN, // 4
-    IDN, IDN, IDN, IDN, IDN, IDN, IDN, IDN, IDN, IDN, IDN, BTO, IDN, BTC, CRT, IDN, // 5
-    TPL, L_A, L_B, L_C, L_D, L_E, L_F, L_G, L_H, L_I, L_J, L_K, L_L, L_M, L_N, L_O, // 6
-    L_P, L_Q, L_R, L_S, L_T, L_U, L_V, L_W, L_X, L_Y, L_Z, BEO, PIP, BEC, TLD, ERR, // 7
-    UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, // 8
-    UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, // 9
-    UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, // A
-    UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, // B
-    UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, // C
-    UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, // D
-    UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, // E
-    UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, // F
-];
-
-const ___: ByteHandler = None;
-
-const EOF: ByteHandler = Some(|lexer| {
-    lexer.input.bump_bytes(1);
-
-    Ok(None)
-});
-
-const ERR: ByteHandler = Some(|lexer| {
-    let c = unsafe {
-        // Safety: Byte handler is only called for non-last chracters
-        lexer.input.cur().unwrap_unchecked()
-    };
-
-    let start = lexer.cur_pos();
-    unsafe {
-        // Safety: Byte handler is only called for non-last chracters
-        lexer.input.bump();
-    }
-    lexer.error_span(pos_span(start), SyntaxError::UnexpectedChar { c })?
-});
-
-/// Identifier and we know that this cannot be a keyword or known ident.
-const IDN: ByteHandler = Some(|lexer| lexer.read_ident_unknown().map(Some));
-
-const L_A: ByteHandler = Some(|lexer| {
-    lexer.read_word_with(&|s| match s {
-        "abstract" => Some(Word::Ident(IdentLike::Known(KnownIdent::Abstract))),
-        "as" => Some(Word::Ident(IdentLike::Known(KnownIdent::As))),
-        "await" => Some(Word::Keyword(Keyword::Await)),
-        "async" => Some(Word::Ident(IdentLike::Known(KnownIdent::Async))),
-        "assert" => Some(Word::Ident(IdentLike::Known(KnownIdent::Assert))),
-        "asserts" => Some(Word::Ident(IdentLike::Known(KnownIdent::Asserts))),
-        "any" => Some(Word::Ident(IdentLike::Known(KnownIdent::Any))),
-        "accessor" => Some(Word::Ident(IdentLike::Known(KnownIdent::Accessor))),
-        _ => None,
-    })
-});
-
-const L_B: ByteHandler = Some(|lexer| {
-    lexer.read_word_with(&|s| match s {
-        "break" => Some(Word::Keyword(Keyword::Break)),
-        "boolean" => Some(Word::Ident(IdentLike::Known(KnownIdent::Boolean))),
-        "bigint" => Some(Word::Ident(IdentLike::Known(KnownIdent::Bigint))),
-        _ => None,
-    })
-});
-
-const L_C: ByteHandler = Some(|lexer| {
-    lexer.read_word_with(&|s| match s {
-        "case" => Some(Word::Keyword(Keyword::Case)),
-        "catch" => Some(Word::Keyword(Keyword::Catch)),
-        "class" => Some(Word::Keyword(Keyword::Class)),
-        "const" => Some(Word::Keyword(Keyword::Const)),
-        "continue" => Some(Word::Keyword(Keyword::Continue)),
-        _ => None,
-    })
-});
-
-const L_D: ByteHandler = Some(|lexer| {
-    lexer.read_word_with(&|s| match s {
-        "debugger" => Some(Word::Keyword(Keyword::Debugger)),
-        "default" => Some(Word::Keyword(Keyword::Default_)),
-        "delete" => Some(Word::Keyword(Keyword::Delete)),
-        "do" => Some(Word::Keyword(Keyword::Do)),
-        "declare" => Some(Word::Ident(IdentLike::Known(KnownIdent::Declare))),
-        _ => None,
-    })
-});
-
-const L_E: ByteHandler = Some(|lexer| {
-    lexer.read_word_with(&|s| match s {
-        "else" => Some(Word::Keyword(Keyword::Else)),
-        "enum" => Some(Word::Ident(IdentLike::Known(KnownIdent::Enum))),
-        "export" => Some(Word::Keyword(Keyword::Export)),
-        "extends" => Some(Word::Keyword(Keyword::Extends)),
-        _ => None,
-    })
-});
-
-const L_F: ByteHandler = Some(|lexer| {
-    lexer.read_word_with(&|s| match s {
-        "false" => Some(Word::False),
-        "finally" => Some(Word::Keyword(Keyword::Finally)),
-        "for" => Some(Word::Keyword(Keyword::For)),
-        "function" => Some(Word::Keyword(Keyword::Function)),
-        "from" => Some(Word::Ident(IdentLike::Known(KnownIdent::From))),
-        _ => None,
-    })
-});
-
-const L_G: ByteHandler = Some(|lexer| {
-    lexer.read_word_with(&|s| match s {
-        "global" => Some(Word::Ident(IdentLike::Known(KnownIdent::Global))),
-        "get" => Some(Word::Ident(IdentLike::Known(KnownIdent::Get))),
-        _ => None,
-    })
-});
-
-const L_H: ByteHandler = IDN;
-
-const L_I: ByteHandler = Some(|lexer| {
-    lexer.read_word_with(&|s| match s {
-        "if" => Some(Word::Keyword(Keyword::If)),
-        "import" => Some(Word::Keyword(Keyword::Import)),
-        "in" => Some(Word::Keyword(Keyword::In)),
-        "instanceof" => Some(Word::Keyword(Keyword::InstanceOf)),
-        "is" => Some(Word::Ident(IdentLike::Known(KnownIdent::Is))),
-        "infer" => Some(Word::Ident(IdentLike::Known(KnownIdent::Infer))),
-        "interface" => Some(Word::Ident(IdentLike::Known(KnownIdent::Interface))),
-        "implements" => Some(Word::Ident(IdentLike::Known(KnownIdent::Implements))),
-        "intrinsic" => Some(Word::Ident(IdentLike::Known(KnownIdent::Intrinsic))),
-        _ => None,
-    })
-});
-
-const L_J: ByteHandler = IDN;
-
-const L_K: ByteHandler = Some(|lexer| {
-    lexer.read_word_with(&|s| match s {
-        "keyof" => Some(Word::Ident(IdentLike::Known(KnownIdent::Keyof))),
-        _ => None,
-    })
-});
-
-const L_L: ByteHandler = Some(|lexer| {
-    lexer.read_word_with(&|s| match s {
-        "let" => Some(Word::Keyword(Keyword::Let)),
-        _ => None,
-    })
-});
-
-const L_M: ByteHandler = Some(|lexer| {
-    lexer.read_word_with(&|s| match s {
-        "meta" => Some(Word::Ident(IdentLike::Known(KnownIdent::Meta))),
-        _ => None,
-    })
-});
-
-const L_N: ByteHandler = Some(|lexer| {
-    lexer.read_word_with(&|s| match s {
-        "new" => Some(Word::Keyword(Keyword::New)),
-        "null" => Some(Word::Null),
-        "number" => Some(Word::Ident(IdentLike::Known(KnownIdent::Number))),
-        "never" => Some(Word::Ident(IdentLike::Known(KnownIdent::Never))),
-        "namespace" => Some(Word::Ident(IdentLike::Known(KnownIdent::Namespace))),
-        _ => None,
-    })
-});
-
-const L_O: ByteHandler = Some(|lexer| {
-    lexer.read_word_with(&|s| match s {
-        "of" => Some(Word::Ident(IdentLike::Known(KnownIdent::Of))),
-        "object" => Some(Word::Ident(IdentLike::Known(KnownIdent::Object))),
-        _ => None,
-    })
-});
-
-const L_P: ByteHandler = Some(|lexer| {
-    lexer.read_word_with(&|s| match s {
-        "public" => Some(Word::Ident(IdentLike::Known(KnownIdent::Public))),
-        "package" => Some(Word::Ident(IdentLike::Known(KnownIdent::Package))),
-        "protected" => Some(Word::Ident(IdentLike::Known(KnownIdent::Protected))),
-        "private" => Some(Word::Ident(IdentLike::Known(KnownIdent::Private))),
-        _ => None,
-    })
-});
-
-const L_Q: ByteHandler = IDN;
-
-const L_R: ByteHandler = Some(|lexer| {
-    lexer.read_word_with(&|s| match s {
-        "return" => Some(Word::Keyword(Keyword::Return)),
-        "readonly" => Some(Word::Ident(IdentLike::Known(KnownIdent::Readonly))),
-        "require" => Some(Word::Ident(IdentLike::Known(KnownIdent::Require))),
-        _ => None,
-    })
-});
-
-const L_S: ByteHandler = Some(|lexer| {
-    lexer.read_word_with(&|s| match s {
-        "super" => Some(Word::Keyword(Keyword::Super)),
-        "static" => Some(Word::Ident(IdentLike::Known(KnownIdent::Static))),
-        "switch" => Some(Word::Keyword(Keyword::Switch)),
-        "symbol" => Some(Word::Ident(IdentLike::Known(KnownIdent::Symbol))),
-        "set" => Some(Word::Ident(IdentLike::Known(KnownIdent::Set))),
-        "string" => Some(Word::Ident(IdentLike::Known(KnownIdent::String))),
-        "satisfies" => Some(Word::Ident(IdentLike::Known(KnownIdent::Satisfies))),
-        _ => None,
-    })
-});
-
-const L_T: ByteHandler = Some(|lexer| {
-    lexer.read_word_with(&|s| match s {
-        "this" => Some(Word::Keyword(Keyword::This)),
-        "throw" => Some(Word::Keyword(Keyword::Throw)),
-        "true" => Some(Word::True),
-        "typeof" => Some(Word::Keyword(Keyword::TypeOf)),
-        "try" => Some(Word::Keyword(Keyword::Try)),
-        "type" => Some(Word::Ident(IdentLike::Known(KnownIdent::Type))),
-        "target" => Some(Word::Ident(IdentLike::Known(KnownIdent::Target))),
-        _ => None,
-    })
-});
-
-const L_U: ByteHandler = Some(|lexer| {
-    lexer.read_word_with(&|s| match s {
-        "using" => Some(Word::Ident(IdentLike::Known(KnownIdent::Using))),
-        "unique" => Some(Word::Ident(IdentLike::Known(KnownIdent::Unique))),
-        "undefined" => Some(Word::Ident(IdentLike::Known(KnownIdent::Undefined))),
-        "unknown" => Some(Word::Ident(IdentLike::Known(KnownIdent::Unknown))),
-        _ => None,
-    })
-});
-
-const L_V: ByteHandler = Some(|lexer| {
-    lexer.read_word_with(&|s| match s {
-        "var" => Some(Word::Keyword(Keyword::Var)),
-        "void" => Some(Word::Keyword(Keyword::Void)),
-        _ => None,
-    })
-});
-
-const L_W: ByteHandler = Some(|lexer| {
-    lexer.read_word_with(&|s| match s {
-        "while" => Some(Word::Keyword(Keyword::While)),
-        "with" => Some(Word::Keyword(Keyword::With)),
-        _ => None,
-    })
-});
-
-const L_X: ByteHandler = IDN;
-
-const L_Y: ByteHandler = Some(|lexer| {
-    lexer.read_word_with(&|s| match s {
-        "yield" => Some(Word::Keyword(Keyword::Yield)),
-        _ => None,
-    })
-});
-
-const L_Z: ByteHandler = IDN;
-
-/// `0`
-const ZER: ByteHandler = Some(|lexer| lexer.read_token_zero().map(Some));
-
-/// Numbers
-const DIG: ByteHandler = Some(|lexer| {
-    lexer
-        .read_number(false)
-        .map(|v| match v {
-            Either::Left((value, raw)) => Token::Num { value, raw },
-            Either::Right((value, raw)) => Token::BigInt { value, raw },
-        })
-        .map(Some)
-});
-
-/// String literals with `'` or `"`
-const QOT: ByteHandler = Some(|lexer| lexer.read_str_lit().map(Some));
-
-/// Unicode
-const UNI: ByteHandler = Some(|lexer| {
-    let c = unsafe {
-        // Safety: Byte handler is only called for non-last chracters
-        lexer.input.cur().unwrap_unchecked()
-    };
-
-    // Identifier or keyword. '\uXXXX' sequences are allowed in
-    // identifiers, so '\' also dispatches to that.
-    if c == '\\' || c.is_ident_start() {
-        return lexer.read_ident_unknown().map(Some);
-    }
-
-    let start = lexer.cur_pos();
-    unsafe {
-        // Safety: Byte handler is only called for non-last chracters
-        lexer.input.bump();
-    }
-    lexer.error_span(pos_span(start), SyntaxError::UnexpectedChar { c })?
-});
-
-/// `:`
-const COL: ByteHandler = Some(|lexer| lexer.read_token_colon().map(Some));
-
-/// `%`
-const PRC: ByteHandler = Some(|lexer| lexer.read_token_mul_mod(b'%').map(Some));
-
-/// `*`
-const ATR: ByteHandler = Some(|lexer| lexer.read_token_mul_mod(b'*').map(Some));
-
-/// `?`
-const QST: ByteHandler = Some(|lexer| lexer.read_token_question_mark().map(Some));
-
-/// `&`
-const AMP: ByteHandler = Some(|lexer| lexer.read_token_logical(b'&').map(Some));
-
-/// `|`
-const PIP: ByteHandler = Some(|lexer| lexer.read_token_logical(b'|').map(Some));
-
-macro_rules! single_char {
-    ($name:ident, $c:literal, $token:ident) => {
-        const $name: ByteHandler = Some(|lexer| {
-            lexer.input.bump_bytes(1);
-            Ok(Some(Token::$token))
-        });
-    };
-}
-
-single_char!(SEM, b';', Semi);
-single_char!(COM, b',', Comma);
-single_char!(TPL, b'`', BackQuote);
-single_char!(TLD, b'~', Tilde);
-single_char!(AT_, b'@', At);
-
-single_char!(PNO, b'(', LParen);
-single_char!(PNC, b')', RParen);
-
-single_char!(BTO, b'[', LBracket);
-single_char!(BTC, b']', RBracket);
-
-single_char!(BEO, b'{', LBrace);
-single_char!(BEC, b'}', RBrace);
-
-/// `^`
-const CRT: ByteHandler = Some(|lexer| {
-    // Bitwise xor
-    lexer.input.bump_bytes(1);
-    Ok(Some(if lexer.input.cur_as_ascii() == Some(b'=') {
-        lexer.input.bump_bytes(1);
-        Token::AssignOp(AssignOp::BitXorAssign)
-    } else {
-        Token::BinOp(BinOpToken::BitXor)
-    }))
-});
-
-/// `+`
-const PLS: ByteHandler = Some(|lexer| lexer.read_token_plus_minus(b'+'));
-
-/// `-`
-const MIN: ByteHandler = Some(|lexer| lexer.read_token_plus_minus(b'-'));
-
-/// `!`
-const EXL: ByteHandler = Some(|lexer| lexer.read_token_bang_or_eq(b'!'));
-
-/// `=`
-const EQL: ByteHandler = Some(|lexer| lexer.read_token_bang_or_eq(b'='));
-
-/// `.`
-const PRD: ByteHandler = Some(|lexer| lexer.read_token_dot().map(Some));
-
-/// `<`
-const LSS: ByteHandler = Some(|lexer| lexer.read_token_lt_gt());
-
-/// `>`
-const MOR: ByteHandler = Some(|lexer| lexer.read_token_lt_gt());
-
-/// `/`
-const SLH: ByteHandler = Some(|lexer| lexer.read_slash());
-
-/// `#`
-const HSH: ByteHandler = Some(|lexer| lexer.read_token_number_sign());
diff --git a/crates/swc_ecma_parser/src/lexer/util.rs b/crates/swc_ecma_parser/src/lexer/util.rs
index 0dd8c52a834d..464ba459fd62 100644
--- a/crates/swc_ecma_parser/src/lexer/util.rs
+++ b/crates/swc_ecma_parser/src/lexer/util.rs
@@ -11,10 +11,7 @@ use swc_common::{
 use swc_ecma_ast::Ident;
 use tracing::warn;
 
-use super::{
-    comments_buffer::BufferedComment, input::Input, whitespace::SkipWhitespace, Char, LexResult,
-    Lexer,
-};
+use super::{comments_buffer::BufferedComment, Char, LexResult, Lexer};
 use crate::{
     error::{Error, SyntaxError},
     lexer::comments_buffer::BufferedCommentKind,
@@ -22,8 +19,8 @@ use crate::{
 };
 
 impl Lexer<'_> {
-    pub(super) fn span(&self, start: BytePos) -> Span {
-        let end = self.last_pos();
+    pub(super) fn span(&mut self, start: BytePos) -> Span {
+        let end = self.input.cur_hi();
         if cfg!(debug_assertions) && start > end {
             unreachable!(
                 "assertion failed: (span.start <= span.end).
@@ -36,50 +33,7 @@ impl Lexer<'_> {
 
     #[inline(always)]
     pub(super) fn bump(&mut self) {
-        unsafe {
-            // Safety: Actually this is not safe but this is an internal method.
-            self.input.bump()
-        }
-    }
-
-    #[inline(always)]
-    pub(super) fn is(&mut self, c: u8) -> bool {
-        self.input.is_byte(c)
-    }
-
-    #[inline(always)]
-    pub(super) fn is_str(&self, s: &str) -> bool {
-        self.input.is_str(s)
-    }
-
-    #[inline(always)]
-    pub(super) fn eat(&mut self, c: u8) -> bool {
-        self.input.eat_byte(c)
-    }
-
-    #[inline(always)]
-    pub(super) fn cur(&mut self) -> Option<char> {
-        self.input.cur()
-    }
-
-    #[inline(always)]
-    pub(super) fn peek(&mut self) -> Option<char> {
-        self.input.peek()
-    }
-
-    #[inline(always)]
-    pub(super) fn peek_ahead(&mut self) -> Option<char> {
-        self.input.peek_ahead()
-    }
-
-    #[inline(always)]
-    pub(super) fn cur_pos(&mut self) -> BytePos {
-        self.input.cur_pos()
-    }
-
-    #[inline(always)]
-    pub(super) fn last_pos(&self) -> BytePos {
-        self.input.last_pos()
+        self.input.next();
     }
 
     /// Shorthand for `let span = self.span(start); self.error_span(span)`
@@ -152,149 +106,6 @@ impl Lexer<'_> {
         self.add_module_mode_error(err);
     }
 
-    /// Skip comments or whitespaces.
-    ///
-    /// See https://tc39.github.io/ecma262/#sec-white-space
-    #[inline(never)]
-    pub(super) fn skip_space<const LEX_COMMENTS: bool>(&mut self) {
-        loop {
-            let (offset, newline) = {
-                let mut skip = SkipWhitespace {
-                    input: self.input.as_str(),
-                    newline: false,
-                    offset: 0,
-                };
-
-                skip.scan();
-
-                (skip.offset, skip.newline)
-            };
-
-            self.input.bump_bytes(offset as usize);
-            if newline {
-                self.state.had_line_break = true;
-            }
-
-            if LEX_COMMENTS && self.input.is_byte(b'/') {
-                if self.peek() == Some('/') {
-                    self.skip_line_comment(2);
-                    continue;
-                } else if self.peek() == Some('*') {
-                    self.skip_block_comment();
-                    continue;
-                }
-            }
-
-            break;
-        }
-    }
-
-    #[inline(never)]
-    pub(super) fn skip_line_comment(&mut self, start_skip: usize) {
-        let start = self.cur_pos();
-        self.input.bump_bytes(start_skip);
-        let slice_start = self.cur_pos();
-
-        // foo // comment for foo
-        // bar
-        //
-        // foo
-        // // comment for bar
-        // bar
-        //
-        let is_for_next = self.state.had_line_break || !self.state.can_have_trailing_line_comment();
-
-        let idx = self
-            .input
-            .as_str()
-            .find(['\r', '\n', '\u{2028}', '\u{2029}'])
-            .map_or(self.input.as_str().len(), |v| {
-                self.state.had_line_break = true;
-                v
-            });
-
-        self.input.bump_bytes(idx);
-        let end = self.cur_pos();
-
-        if let Some(comments) = self.comments_buffer.as_mut() {
-            let s = unsafe {
-                // Safety: We know that the start and the end are valid
-                self.input.slice(slice_start, end)
-            };
-            let cmt = Comment {
-                kind: CommentKind::Line,
-                span: Span::new(start, end),
-                text: self.atoms.atom(s),
-            };
-
-            if is_for_next {
-                comments.push_pending_leading(cmt);
-            } else {
-                comments.push(BufferedComment {
-                    kind: BufferedCommentKind::Trailing,
-                    pos: self.state.prev_hi,
-                    comment: cmt,
-                });
-            }
-        }
-
-        unsafe {
-            // Safety: We got end from self.input
-            self.input.reset_to(end);
-        }
-    }
-
-    /// Expects current char to be '/' and next char to be '*'.
-    #[inline(never)]
-    pub(super) fn skip_block_comment(&mut self) {
-        let start = self.cur_pos();
-
-        debug_assert_eq!(self.cur(), Some('/'));
-        debug_assert_eq!(self.peek(), Some('*'));
-
-        self.input.bump_bytes(2);
-
-        // jsdoc
-        let slice_start = self.cur_pos();
-        let mut was_star = if self.input.is_byte(b'*') {
-            self.bump();
-            true
-        } else {
-            false
-        };
-
-        let mut is_for_next = self.state.had_line_break || !self.state.can_have_trailing_comment();
-
-        while let Some(c) = self.cur() {
-            if was_star && c == '/' {
-                debug_assert_eq!(self.cur(), Some('/'));
-                self.bump(); // '/'
-
-                let end = self.cur_pos();
-
-                self.skip_space::<false>();
-
-                if self.input.is_byte(b';') {
-                    is_for_next = false;
-                }
-
-                self.store_comment(is_for_next, start, end, slice_start);
-
-                return;
-            }
-            if c.is_line_terminator() {
-                self.state.had_line_break = true;
-            }
-
-            was_star = c == '*';
-            self.bump();
-        }
-
-        let end = self.input.end_pos();
-        let span = Span::new(end, end);
-        self.emit_error_span(span, SyntaxError::UnterminatedBlockComment)
-    }
-
     #[inline(never)]
     fn store_comment(
         &mut self,
diff --git a/crates/swc_ecma_parser/src/lexer/whitespace.rs b/crates/swc_ecma_parser/src/lexer/whitespace.rs
deleted file mode 100644
index cba91fa0158c..000000000000
--- a/crates/swc_ecma_parser/src/lexer/whitespace.rs
+++ /dev/null
@@ -1,100 +0,0 @@
-/// Returns true if it's done
-pub(super) type ByteHandler = Option<for<'aa> fn(&mut SkipWhitespace<'aa>) -> u32>;
-
-/// Lookup table for whitespace
-static BYTE_HANDLERS: [ByteHandler; 256] = [
-    //   0    1    2    3    4    5    6    7    8    9    A    B    C    D    E    F   //
-    ___, ___, ___, ___, ___, ___, ___, ___, ___, SPC, NLN, SPC, SPC, NLN, ___, ___, // 0
-    ___, ___, ___, ___, ___, ___, ___, ___, ___, ___, ___, ___, ___, ___, ___, ___, // 1
-    SPC, ___, ___, ___, ___, ___, ___, ___, ___, ___, ___, ___, ___, ___, ___, ___, // 2
-    ___, ___, ___, ___, ___, ___, ___, ___, ___, ___, ___, ___, ___, ___, ___, ___, // 3
-    ___, ___, ___, ___, ___, ___, ___, ___, ___, ___, ___, ___, ___, ___, ___, ___, // 4
-    ___, ___, ___, ___, ___, ___, ___, ___, ___, ___, ___, ___, ___, ___, ___, ___, // 5
-    ___, ___, ___, ___, ___, ___, ___, ___, ___, ___, ___, ___, ___, ___, ___, ___, // 6
-    ___, ___, ___, ___, ___, ___, ___, ___, ___, ___, ___, ___, ___, ___, ___, ___, // 7
-    UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, // 8
-    UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, // 9
-    UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, // A
-    UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, // B
-    UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, // C
-    UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, // D
-    UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, // E
-    UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, UNI, // F
-];
-
-/// Stop
-const ___: ByteHandler = None;
-
-/// Newline
-const NLN: ByteHandler = Some(|skip| {
-    skip.newline = true;
-
-    1
-});
-
-/// Space
-const SPC: ByteHandler = Some(|_| 1);
-
-/// Unicode
-const UNI: ByteHandler = Some(|skip| {
-    let s = unsafe {
-        // Safety: `skip.offset` is always valid
-        skip.input.get_unchecked(skip.offset as usize..)
-    };
-
-    let c = unsafe {
-        // Safety: Byte handlers are called only when `skip.input` is not empty
-        s.chars().next().unwrap_unchecked()
-    };
-
-    match c {
-        // white spaces
-        '\u{feff}' => {}
-        // line breaks
-        '\u{2028}' | '\u{2029}' => {
-            skip.newline = true;
-        }
-
-        _ if c.is_whitespace() => {}
-
-        _ => return 0,
-    }
-
-    c.len_utf8() as u32
-});
-
-/// API is taked from oxc by Boshen (https://github.com/Boshen/oxc/pull/26)
-pub(super) struct SkipWhitespace<'a> {
-    pub input: &'a str,
-
-    /// Total offset
-    pub offset: u32,
-
-    /// Found newline
-    pub newline: bool,
-}
-
-impl SkipWhitespace<'_> {
-    #[inline(always)]
-    pub fn scan(&mut self) {
-        let mut byte;
-        loop {
-            byte = match self.input.as_bytes().get(self.offset as usize).copied() {
-                Some(v) => v,
-                None => return,
-            };
-
-            let handler = unsafe { *(&BYTE_HANDLERS as *const ByteHandler).offset(byte as isize) };
-
-            if let Some(handler) = handler {
-                let delta = handler(self);
-                if delta == 0 {
-                    return;
-                }
-                self.offset += delta;
-            } else {
-                return;
-            }
-        }
-    }
-}
diff --git a/crates/swc_ecma_parser/src/lib.rs b/crates/swc_ecma_parser/src/lib.rs
index e2ed67dbff1f..2b52099681d2 100644
--- a/crates/swc_ecma_parser/src/lib.rs
+++ b/crates/swc_ecma_parser/src/lib.rs
@@ -116,7 +116,6 @@
 #![cfg_attr(docsrs, feature(doc_cfg))]
 #![cfg_attr(test, feature(test))]
 #![deny(clippy::all)]
-#![deny(unused)]
 #![allow(clippy::nonminimal_bool)]
 #![allow(clippy::too_many_arguments)]
 #![allow(clippy::unnecessary_unwrap)]
diff --git a/crates/swc_ecma_parser/src/token.rs b/crates/swc_ecma_parser/src/token.rs
index c333ab8e1359..af9f4e3cb2bc 100644
--- a/crates/swc_ecma_parser/src/token.rs
+++ b/crates/swc_ecma_parser/src/token.rs
@@ -980,10 +980,10 @@ impl Debug for Token {
             Regex(exp, flags) => write!(f, "regexp literal ({}, {})", exp, flags)?,
             Num { value, raw, .. } => write!(f, "numeric literal ({}, {})", value, raw)?,
             BigInt { value, raw } => write!(f, "bigint literal ({}, {})", value, raw)?,
-            JSXName { name } => write!(f, "jsx name ({})", name)?,
-            JSXText { raw, .. } => write!(f, "jsx text ({})", raw)?,
-            JSXTagStart => write!(f, "< (jsx tag start)")?,
-            JSXTagEnd => write!(f, "> (jsx tag end)")?,
+            JSXName { name } => write!(f, "{} (jsx name)", name)?,
+            JSXText { raw, .. } => write!(f, "{} (jsx text)", raw)?,
+            JSXTagStart => write!(f, "< (jsx)")?,
+            JSXTagEnd => write!(f, "> (jsx)")?,
             Shebang(_) => write!(f, "#!")?,
             Token::Error(e) => write!(f, "<lexing error: {:?}>", e)?,
         }
diff --git a/crates/swc_ecma_raw_lexer/Cargo.toml b/crates/swc_ecma_raw_lexer/Cargo.toml
new file mode 100644
index 000000000000..e1401e6607a4
--- /dev/null
+++ b/crates/swc_ecma_raw_lexer/Cargo.toml
@@ -0,0 +1,19 @@
+[package]
+authors       = ["강동윤 <kdy1997.dev@gmail.com>"]
+description   = "Raw lexer for swc"
+documentation = "https://rustdoc.swc.rs/swc_ecma_raw_lexer/"
+edition       = { workspace = true }
+include       = ["Cargo.toml", "src/**/*.rs", "examples/**/*.rs"]
+license       = { workspace = true }
+name          = "swc_ecma_raw_lexer"
+repository    = { workspace = true }
+version       = "0.1.0"
+
+[dependencies]
+logos                 = { workspace = true }
+new_debug_unreachable = { workspace = true }
+swc_common            = { version = "5.0.0", path = "../swc_common" }
+
+[dev-dependencies]
+pretty_assertions = { workspace = true }
+regex             = { workspace = true }
diff --git a/crates/swc_ecma_raw_lexer/src/jsx.rs b/crates/swc_ecma_raw_lexer/src/jsx.rs
new file mode 100644
index 000000000000..43d72c28d416
--- /dev/null
+++ b/crates/swc_ecma_raw_lexer/src/jsx.rs
@@ -0,0 +1,7 @@
+use logos::Logos;
+
+use crate::LogosError;
+
+#[derive(Logos, Debug, Clone, Copy, PartialEq, Eq)]
+#[logos(error = LogosError)]
+pub enum JsxToken {}
diff --git a/crates/swc_ecma_raw_lexer/src/lib.rs b/crates/swc_ecma_raw_lexer/src/lib.rs
new file mode 100644
index 000000000000..38653278d231
--- /dev/null
+++ b/crates/swc_ecma_raw_lexer/src/lib.rs
@@ -0,0 +1,722 @@
+//! This package is considered internal and should not be used by external
+//! crates.
+//!
+//! It may updated without proper semver bump.
+
+use std::fmt::Debug;
+
+use logos::{Lexer, Logos, Skip};
+use swc_common::{input::StringInput, BytePos};
+
+use crate::{
+    peek::{peek_nth, PeekNth},
+    string::{consume_str_double_quote, consume_str_single_quote},
+};
+
+pub mod jsx;
+mod peek;
+mod regexp;
+mod size_hint;
+mod string;
+
+/// A lexer that can be used to create [RawToken].
+#[derive(Clone)]
+pub struct RawLexer<'a> {
+    lexer: PeekNth<logos::SpannedIter<'a, RawToken>>,
+    base_pos: BytePos,
+    pos: BytePos,
+    orig_str: &'a str,
+    start_pos: BytePos,
+    end_pos: BytePos,
+}
+
+impl Debug for RawLexer<'_> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "RawBuffer {{ pos: {:?} }}", self.pos)
+    }
+}
+
+#[derive(Debug, Clone, Default)]
+pub struct TokenState {
+    pub had_line_break: bool,
+}
+
+impl<'a> RawLexer<'a> {
+    pub fn new(input: StringInput<'a>) -> Self {
+        Self {
+            lexer: peek_nth(logos::Lexer::new(input.as_str()).spanned()),
+            base_pos: input.start_pos(),
+            pos: input.start_pos(),
+            orig_str: input.as_str(),
+            start_pos: input.start_pos(),
+            end_pos: input.end_pos(),
+        }
+    }
+
+    pub const fn start_pos(&self) -> BytePos {
+        self.start_pos
+    }
+
+    pub const fn end_pos(&self) -> BytePos {
+        self.end_pos
+    }
+
+    pub fn cur_pos(&self) -> BytePos {
+        self.pos
+    }
+
+    pub fn cur_hi(&mut self) -> BytePos {
+        let span = self.lexer.peek().map(|v| v.1.clone()).unwrap_or_default();
+
+        // +1 because hi is exclusive
+        self.pos + BytePos(span.len() as u32 + 1)
+    }
+
+    pub fn update_cur_pos(&mut self) -> BytePos {
+        let span = self.lexer.peek().map(|v| v.1.clone()).unwrap_or_default();
+        self.pos = self.base_pos + BytePos(span.start as u32);
+        self.pos
+    }
+
+    pub fn cur(&mut self) -> Result<Option<RawToken>, LogosError> {
+        self.lexer.peek().map(|(t, _)| *t).transpose()
+    }
+
+    pub fn peek(&mut self) -> Result<Option<RawToken>, LogosError> {
+        self.lexer.peek_nth(1).map(|(t, _)| *t).transpose()
+    }
+
+    pub fn peek_ahead(&mut self) -> Result<Option<RawToken>, LogosError> {
+        self.lexer.peek_nth(2).map(|(t, _)| *t).transpose()
+    }
+
+    pub fn cur_char(&mut self) -> Option<char> {
+        let lo = self.pos.0 - self.start_pos.0;
+
+        let source = unsafe {
+            // Safety: self.pos is always within the bounds of `self.orig_str` and it's
+            // always at the char boundary
+            self.orig_str.get_unchecked(lo as usize..)
+        };
+
+        source.chars().next()
+    }
+
+    pub fn peek_char(&mut self) -> Option<char> {
+        self.reset_peeked();
+
+        self.lexer.inner_mut().remainder().chars().nth(1)
+    }
+
+    pub fn peek_ahead_char(&mut self) -> Option<char> {
+        self.reset_peeked();
+
+        self.lexer.inner_mut().remainder().chars().nth(2)
+    }
+
+    /// # Safety
+    ///
+    ///  - `start` and `end` must be within the bounds of `self.orig_str`
+    pub unsafe fn slice(&self, start: BytePos, end: BytePos) -> &str {
+        let lo = start.0 - self.start_pos.0;
+        let hi = end.0 - self.start_pos.0;
+
+        self.orig_str.get_unchecked(lo as usize..hi as usize)
+    }
+
+    pub fn cur_slice(&mut self) -> &str {
+        let Some((_, span)) = self.lexer.peek() else {
+            return "";
+        };
+        let span = span.clone();
+
+        unsafe {
+            // Safety: `span` is within the bounds of `self.lexer` because we get it from
+            // `self.lexer.next()`
+            self.lexer.inner_mut().source().get_unchecked(span)
+        }
+    }
+
+    /// # Safety
+    ///
+    /// - `n` must be equal or smaller than  lefting length of `self.orig_str`
+    pub unsafe fn bump(&mut self, n: usize) {
+        self.reset_peeked();
+
+        self.lexer.inner_mut().bump(n);
+        if let Some((_, span)) = self.lexer.peek() {
+            self.pos = self.base_pos + BytePos(span.start as u32);
+        }
+    }
+
+    pub fn eat(&mut self, token: RawToken) -> bool {
+        let Ok(Some(cur)) = self.cur() else {
+            return false;
+        };
+
+        if cur == token {
+            self.next();
+            true
+        } else {
+            false
+        }
+    }
+
+    pub fn is_ascii(&mut self, c: u8) -> bool {
+        self.cur_char() == Some(c as char)
+    }
+
+    pub fn eat_ascii(&mut self, c: u8) -> bool {
+        let cur = self.cur_char();
+
+        if cur == Some(c as char) {
+            unsafe {
+                // Safety: We already checked for the current char
+                self.bump(1);
+            }
+            true
+        } else {
+            false
+        }
+    }
+
+    /// # Safety
+    ///
+    /// - `pos` must be within the bounds of `self.orig_str`
+    pub unsafe fn reset_to(&mut self, pos: BytePos) {
+        let lo = pos.0 - self.start_pos.0;
+        let hi = self.end_pos.0 - self.start_pos.0;
+
+        let source = self.orig_str.get_unchecked(lo as usize..hi as usize);
+
+        self.lexer = peek_nth(logos::Lexer::new(source).spanned());
+        self.base_pos = pos;
+        self.pos = pos;
+    }
+
+    fn reset_peeked(&mut self) {
+        unsafe {
+            let lo = self.pos.0 - self.start_pos.0;
+
+            // Safety: We already checked for the current char
+            let source = self.orig_str.get_unchecked(lo as usize..);
+
+            self.lexer = peek_nth(logos::Lexer::new(source).spanned());
+        }
+    }
+}
+
+impl Iterator for RawLexer<'_> {
+    type Item = Result<RawToken, LogosError>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        let (previous_token, span) = self.lexer.next()?;
+        self.pos = self.base_pos + BytePos(span.start as u32);
+
+        let item = match previous_token {
+            Ok(item) => item,
+            Err(e) => return Some(Err(e)),
+        };
+
+        Some(Ok(item))
+    }
+}
+
+#[derive(Logos, Debug, Clone, Copy, PartialEq, Eq)]
+#[logos(error = LogosError, extras = TokenState)]
+pub enum RawToken {
+    #[token("=>")]
+    Arrow,
+
+    #[token("#")]
+    Hash,
+
+    #[token("@")]
+    At,
+
+    #[token(".")]
+    Dot,
+
+    #[token("...")]
+    DotDotDot,
+
+    #[token("!")]
+    Bang,
+
+    #[token("(")]
+    LParen,
+
+    #[token(")")]
+    RParen,
+
+    #[token("[")]
+    LBracket,
+
+    #[token("]")]
+    RBracket,
+
+    #[token("{")]
+    LBrace,
+
+    #[token("}")]
+    RBrace,
+
+    #[token(";")]
+    Semi,
+
+    #[token(",")]
+    Comma,
+
+    #[token(":")]
+    Colon,
+
+    #[token("`")]
+    BackQuote,
+
+    #[token("${")]
+    DollarLBrace,
+
+    #[token("?")]
+    QuestionMark,
+
+    #[token("++")]
+    PlusPlus,
+
+    #[token("--")]
+    MinusMinus,
+
+    #[token("~")]
+    Tilde,
+
+    #[token("'", callback = consume_str_single_quote)]
+    #[token("\"", callback = consume_str_double_quote)]
+    Str,
+
+    #[regex(r"(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?")]
+    #[regex(r"0[xX][a-fA-F0-9]+")]
+    #[regex(r"0[oO][0-7]+")]
+    #[regex(r"0[bB][01]+")]
+    Num,
+
+    #[regex(r#"0[0-7]+"#)]
+    LegacyOctalNum,
+
+    #[regex(r#"[0-9]+n"#)]
+    BigInt,
+
+    #[token("#![^ \n\r\t]*")]
+    Shebang,
+
+    #[token("null")]
+    Null,
+
+    #[token("true")]
+    True,
+
+    #[token("false")]
+    False,
+
+    #[token("==")]
+    EqEqOp,
+
+    #[token("!=")]
+    NotEqOp,
+
+    #[token("===")]
+    EqEqEqOp,
+
+    #[token("!==")]
+    NotEqEqOp,
+
+    #[token("<")]
+    LtOp,
+
+    #[token("<=")]
+    LtEqOp,
+
+    #[token(">")]
+    GtOp,
+
+    #[token(">=")]
+    GtEqOp,
+
+    #[token("<<")]
+    LShiftOp,
+
+    #[token(">>")]
+    RShiftOp,
+
+    #[token(">>>")]
+    ZeroFillRShiftOp,
+
+    #[token("+")]
+    AddOp,
+
+    #[token("-")]
+    SubOp,
+
+    #[token("*")]
+    MulOp,
+
+    #[token("/")]
+    DivOp,
+
+    #[token("%")]
+    ModOp,
+
+    #[token("|")]
+    BitOrOp,
+
+    #[token("^")]
+    BitXorOp,
+
+    #[token("&")]
+    BitAndOp,
+
+    #[token("**")]
+    ExpOp,
+
+    #[token("||")]
+    LogicalOrOp,
+
+    #[token("&&")]
+    LogicalAndOp,
+
+    #[token("??")]
+    NullishCoalescingOp,
+
+    #[token("=")]
+    AssignOp,
+
+    #[token("+=")]
+    AddAssignOp,
+
+    #[token("-=")]
+    SubAssignOp,
+
+    #[token("*=")]
+    MulAssignOp,
+
+    #[token("/=")]
+    DivAssignOp,
+
+    #[token("%=")]
+    ModAssignOp,
+
+    #[token("<<=")]
+    LShiftAssignOp,
+
+    #[token(">>=")]
+    RShiftAssignOp,
+
+    #[token(">>>=")]
+    ZeroFillRShiftAssignOp,
+
+    #[token("|=")]
+    BitOrAssignOp,
+
+    #[token("^=")]
+    BitXorAssignOp,
+
+    #[token("&=")]
+    BitAndAssignOp,
+
+    #[token("**=")]
+    ExpAssignOp,
+
+    #[token("&&=")]
+    AndAssignOp,
+
+    #[token("||=")]
+    OrAssignOp,
+
+    #[token("??=")]
+    NullishAssignOp,
+
+    /// TODO: Move jsx lexing to RawLexer
+    JsxTagStart,
+    /// TODO: Move jsx lexing to RawLexer
+    JsxTagEnd,
+
+    #[regex(r"([\p{XID_Start}_$]|\\u[a-fA-F0-9]{4})([\p{XID_Continue}_$]|\\u[a-fA-F0-9]{4})*")]
+    Ident,
+
+    #[regex("[\n|\r]+", priority = 5, callback = newline_callback)]
+    NewLine,
+
+    #[regex(r"[ \t]+", callback = whitespace_callback)]
+    Whitespace,
+
+    #[regex(r"//[^\n]*")]
+    LineComment,
+
+    #[regex(r"/\*(?:[^*]|\*[^/])*\*/")]
+    BlockComment,
+
+    #[token("<!--")]
+    LegacyCommentOpen,
+
+    #[token("-->")]
+    LegacyCommentClose,
+
+    #[token("<<<<<<<")]
+    #[token(">>>>>>>")]
+    #[token("=======")]
+    #[token("|||||||")]
+    ConflictMarker,
+
+    #[token("await")]
+    Await,
+
+    #[token("break")]
+    Break,
+
+    #[token("case")]
+    Case,
+
+    #[token("catch")]
+    Catch,
+
+    #[token("continue")]
+    Continue,
+
+    #[token("debugger")]
+    Debugger,
+
+    #[token("default")]
+    Default_,
+
+    #[token("do")]
+    Do,
+
+    #[token("else")]
+    Else,
+
+    #[token("finally")]
+    Finally,
+
+    #[token("for")]
+    For,
+
+    #[token("function")]
+    Function,
+
+    #[token("if")]
+    If,
+
+    #[token("return")]
+    Return,
+
+    #[token("switch")]
+    Switch,
+
+    #[token("throw")]
+    Throw,
+
+    #[token("try")]
+    Try,
+
+    #[token("var")]
+    Var,
+
+    #[token("let")]
+    Let,
+
+    #[token("const")]
+    Const,
+
+    #[token("while")]
+    While,
+
+    #[token("with")]
+    With,
+
+    #[token("new")]
+    New,
+
+    #[token("this")]
+    This,
+
+    #[token("super")]
+    Super,
+
+    #[token("class")]
+    Class,
+
+    #[token("extends")]
+    Extends,
+
+    #[token("export")]
+    Export,
+
+    #[token("import")]
+    Import,
+
+    #[token("yield")]
+    Yield,
+
+    #[token("in")]
+    In,
+
+    #[token("instanceof")]
+    InstanceOf,
+
+    #[token("typeof")]
+    TypeOf,
+
+    #[token("void")]
+    Void,
+
+    #[token("delete")]
+    Delete,
+
+    #[token("abstract")]
+    Abstract,
+
+    #[token("as")]
+    As,
+
+    #[token("async")]
+    Async,
+
+    #[token("from")]
+    From,
+
+    #[token("of")]
+    Of,
+
+    #[token("type")]
+    Type,
+
+    #[token("global")]
+    Global,
+
+    #[token("static")]
+    Static,
+
+    #[token("using")]
+    Using,
+
+    #[token("readonly")]
+    Readonly,
+
+    #[token("unique")]
+    Unique,
+
+    #[token("keyof")]
+    Keyof,
+
+    #[token("declare")]
+    Declare,
+
+    #[token("enum")]
+    Enum,
+
+    #[token("is")]
+    Is,
+
+    #[token("infer")]
+    Infer,
+
+    Symbol,
+
+    #[token("undefined")]
+    Undefined,
+
+    #[token("interface")]
+    Interface,
+
+    #[token("implements")]
+    Implements,
+
+    #[token("asserts")]
+    Asserts,
+
+    #[token("require")]
+    Require,
+
+    #[token("get")]
+    Get,
+
+    #[token("set")]
+    Set,
+
+    #[token("any")]
+    Any,
+
+    #[token("intrinsic")]
+    Intrinsic,
+
+    #[token("unknown")]
+    Unknown,
+
+    #[token("string")]
+    String,
+
+    #[token("object")]
+    Object,
+
+    #[token("number")]
+    Number,
+
+    #[token("bigint")]
+    Bigint,
+
+    #[token("boolean")]
+    Boolean,
+
+    #[token("never")]
+    Never,
+
+    #[token("assert")]
+    Assert,
+
+    #[token("namespace")]
+    Namespace,
+
+    #[token("accessor")]
+    Accessor,
+
+    #[token("meta")]
+    Meta,
+
+    #[token("target")]
+    Target,
+
+    #[token("satisfies")]
+    Satisfies,
+
+    #[token("package")]
+    Package,
+
+    #[token("protected")]
+    Protected,
+
+    #[token("private")]
+    Private,
+
+    #[token("public")]
+    Public,
+}
+
+fn newline_callback(l: &mut Lexer<RawToken>) -> Skip {
+    l.extras.had_line_break = true;
+    Skip
+}
+
+fn whitespace_callback(_: &mut Lexer<RawToken>) -> Skip {
+    Skip
+}
+
+impl RawToken {
+    pub fn is_line_terminator(&self) -> bool {
+        matches!(self, RawToken::NewLine)
+    }
+}
+
+#[derive(Debug, Default, Clone, Copy, PartialEq, Eq)]
+pub enum LogosError {
+    #[default]
+    UnknownChar,
+    UnterminatedStr,
+}
diff --git a/crates/swc_ecma_raw_lexer/src/peek.rs b/crates/swc_ecma_raw_lexer/src/peek.rs
new file mode 100644
index 000000000000..65686d3ef7b8
--- /dev/null
+++ b/crates/swc_ecma_raw_lexer/src/peek.rs
@@ -0,0 +1,84 @@
+//! Copied from `itertools`
+
+use std::collections::VecDeque;
+
+use crate::size_hint;
+
+/// See [`peek_nth()`] for more information.
+#[derive(Clone, Debug)]
+#[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
+pub struct PeekNth<I>
+where
+    I: Iterator,
+{
+    iter: I,
+    buf: VecDeque<I::Item>,
+}
+
+/// A drop-in replacement for [`std::iter::Peekable`] which adds a `peek_nth`
+/// method allowing the user to `peek` at a value several iterations forward
+/// without advancing the base iterator.
+///
+/// This differs from `multipeek` in that subsequent calls to `peek` or
+/// `peek_nth` will always return the same value until `next` is called
+/// (making `reset_peek` unnecessary).
+pub fn peek_nth<I>(iterable: I) -> PeekNth<I>
+where
+    I: Iterator,
+{
+    PeekNth {
+        iter: iterable,
+        buf: VecDeque::new(),
+    }
+}
+
+impl<I> PeekNth<I>
+where
+    I: Iterator,
+{
+    /// Works exactly like the `peek` method in [`std::iter::Peekable`].
+    pub fn peek(&mut self) -> Option<&I::Item> {
+        self.peek_nth(0)
+    }
+
+    pub fn peek_nth(&mut self, n: usize) -> Option<&I::Item> {
+        let unbuffered_items = (n + 1).saturating_sub(self.buf.len());
+
+        self.buf.extend(self.iter.by_ref().take(unbuffered_items));
+
+        self.buf.get(n)
+    }
+
+    pub fn inner_mut(&mut self) -> &mut I {
+        &mut self.iter
+    }
+
+    pub fn inner(&self) -> &I {
+        &self.iter
+    }
+}
+
+impl<I> Iterator for PeekNth<I>
+where
+    I: Iterator,
+{
+    type Item = I::Item;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        self.buf.pop_front().or_else(|| self.iter.next())
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        size_hint::add_scalar(self.iter.size_hint(), self.buf.len())
+    }
+
+    fn fold<B, F>(self, mut init: B, mut f: F) -> B
+    where
+        F: FnMut(B, Self::Item) -> B,
+    {
+        init = self.buf.into_iter().fold(init, &mut f);
+        self.iter.fold(init, f)
+    }
+}
+
+impl<I> ExactSizeIterator for PeekNth<I> where I: ExactSizeIterator {}
diff --git a/crates/swc_ecma_raw_lexer/src/regexp.rs b/crates/swc_ecma_raw_lexer/src/regexp.rs
new file mode 100644
index 000000000000..6665ff6324e7
--- /dev/null
+++ b/crates/swc_ecma_raw_lexer/src/regexp.rs
@@ -0,0 +1,43 @@
+use logos::Logos;
+
+use crate::{LogosError, RawLexer};
+
+impl<'a> RawLexer<'a> {
+    /// Current token must be [`RawToken::DivOp`]
+    pub fn read_regexp(&mut self) -> Result<&'a str, LogosError> {
+        self.reset_peeked();
+
+        let s = self.lexer.inner().remainder();
+        let remainder_len = s.len();
+
+        let mut lexer = RegexpContent::lexer(s);
+
+        for token in lexer.by_ref().flatten() {
+            if token == RegexpContent::Terminate {
+                break;
+            }
+        }
+
+        let consumed = remainder_len - lexer.remainder().len();
+
+        self.lexer.inner_mut().bump(consumed);
+
+        Ok(s.get(..consumed).unwrap())
+    }
+}
+
+#[derive(Logos, Debug, Clone, Copy, PartialEq, Eq)]
+#[logos(error = LogosError)]
+enum RegexpContent {
+    #[regex(r#"\[[^\]]+\]"#)]
+    Class,
+
+    #[regex(r#"\\."#)]
+    Escape,
+
+    #[token(r"/")]
+    Terminate,
+
+    #[regex(r#"[^\\\[/]+"#)]
+    Normal,
+}
diff --git a/crates/swc_ecma_raw_lexer/src/size_hint.rs b/crates/swc_ecma_raw_lexer/src/size_hint.rs
new file mode 100644
index 000000000000..dea3e2eb1eb5
--- /dev/null
+++ b/crates/swc_ecma_raw_lexer/src/size_hint.rs
@@ -0,0 +1,95 @@
+//! Copied from `itertools`
+//!     
+//! Arithmetic on `Iterator.size_hint()` values.
+
+use std::cmp;
+
+/// `SizeHint` is the return type of `Iterator::size_hint()`.
+pub type SizeHint = (usize, Option<usize>);
+
+/// Add `SizeHint` correctly.
+#[inline]
+pub fn add(a: SizeHint, b: SizeHint) -> SizeHint {
+    let min = a.0.saturating_add(b.0);
+    let max = match (a.1, b.1) {
+        (Some(x), Some(y)) => x.checked_add(y),
+        _ => None,
+    };
+
+    (min, max)
+}
+
+/// Add `x` correctly to a `SizeHint`.
+#[inline]
+pub fn add_scalar(sh: SizeHint, x: usize) -> SizeHint {
+    let (mut low, mut hi) = sh;
+    low = low.saturating_add(x);
+    hi = hi.and_then(|elt| elt.checked_add(x));
+    (low, hi)
+}
+
+/// Subtract `x` correctly from a `SizeHint`.
+#[inline]
+pub fn sub_scalar(sh: SizeHint, x: usize) -> SizeHint {
+    let (mut low, mut hi) = sh;
+    low = low.saturating_sub(x);
+    hi = hi.map(|elt| elt.saturating_sub(x));
+    (low, hi)
+}
+
+/// Multiply `SizeHint` correctly
+#[inline]
+pub fn mul(a: SizeHint, b: SizeHint) -> SizeHint {
+    let low = a.0.saturating_mul(b.0);
+    let hi = match (a.1, b.1) {
+        (Some(x), Some(y)) => x.checked_mul(y),
+        (Some(0), None) | (None, Some(0)) => Some(0),
+        _ => None,
+    };
+    (low, hi)
+}
+
+/// Multiply `x` correctly with a `SizeHint`.
+#[inline]
+pub fn mul_scalar(sh: SizeHint, x: usize) -> SizeHint {
+    let (mut low, mut hi) = sh;
+    low = low.saturating_mul(x);
+    hi = hi.and_then(|elt| elt.checked_mul(x));
+    (low, hi)
+}
+
+/// Return the maximum
+#[inline]
+pub fn max(a: SizeHint, b: SizeHint) -> SizeHint {
+    let (a_lower, a_upper) = a;
+    let (b_lower, b_upper) = b;
+
+    let lower = cmp::max(a_lower, b_lower);
+
+    let upper = match (a_upper, b_upper) {
+        (Some(x), Some(y)) => Some(cmp::max(x, y)),
+        _ => None,
+    };
+
+    (lower, upper)
+}
+
+/// Return the minimum
+#[inline]
+pub fn min(a: SizeHint, b: SizeHint) -> SizeHint {
+    let (a_lower, a_upper) = a;
+    let (b_lower, b_upper) = b;
+    let lower = cmp::min(a_lower, b_lower);
+    let upper = match (a_upper, b_upper) {
+        (Some(u1), Some(u2)) => Some(cmp::min(u1, u2)),
+        _ => a_upper.or(b_upper),
+    };
+    (lower, upper)
+}
+
+#[test]
+fn mul_size_hints() {
+    assert_eq!(mul((3, Some(4)), (3, Some(4))), (9, Some(16)));
+    assert_eq!(mul((3, Some(4)), (usize::MAX, None)), (usize::MAX, None));
+    assert_eq!(mul((3, None), (0, Some(0))), (0, Some(0)));
+}
diff --git a/crates/swc_ecma_raw_lexer/src/string.rs b/crates/swc_ecma_raw_lexer/src/string.rs
new file mode 100644
index 000000000000..7a32aca49b3e
--- /dev/null
+++ b/crates/swc_ecma_raw_lexer/src/string.rs
@@ -0,0 +1,107 @@
+use logos::{Lexer, Logos};
+
+use crate::{LogosError, RawToken};
+
+pub fn consume_str_single_quote(lex: &mut Lexer<RawToken>) -> Result<(), LogosError> {
+    consume_str(lex, StrContent::SingleQuote)
+}
+
+pub fn consume_str_double_quote(lex: &mut Lexer<RawToken>) -> Result<(), LogosError> {
+    consume_str(lex, StrContent::DoubleQuote)
+}
+
+fn consume_str(lex: &mut Lexer<RawToken>, stop_token: StrContent) -> Result<(), LogosError> {
+    let remainder = lex.remainder();
+    let total_len = remainder.len();
+
+    let mut str_lexer = Lexer::<StrContent>::new(remainder);
+    let mut terminated = false;
+
+    while let Some(Ok(token)) = str_lexer.next() {
+        if token == stop_token {
+            terminated = true;
+            break;
+        }
+    }
+
+    let left_len = str_lexer.remainder().len();
+    let consumed = total_len - left_len;
+    lex.bump(consumed);
+
+    if !terminated {
+        return Err(LogosError::UnterminatedStr);
+    }
+
+    Ok(())
+}
+
+#[derive(Logos, Debug, Clone, Copy, PartialEq, Eq)]
+enum StrContent {
+    #[regex(r#"\\["'\\bfnrtv]"#, priority = 100)]
+    #[regex(r#"\\0[0-7]*"#, priority = 100)]
+    #[regex(r#"\\x[0-9a-fA-F]{2}"#, priority = 100)]
+    #[regex(r#"\\u[0-9a-fA-F]{4}"#, priority = 100)]
+    #[regex(r#"\\[^'"\\]+"#)]
+    Escape,
+
+    #[regex(r#"[^'"\\]+"#)]
+    Normal,
+
+    #[regex(r#"'"#)]
+    SingleQuote,
+
+    #[regex(r#"""#)]
+    DoubleQuote,
+}
+
+#[cfg(test)]
+mod tests {
+    use logos::Lexer;
+    use pretty_assertions::assert_eq;
+
+    use super::StrContent;
+
+    fn assert_str(text: &str, expected: &[StrContent]) {
+        dbg!(text);
+        dbg!(expected);
+
+        let actual = Lexer::<StrContent>::new(text)
+            .map(|v| v.unwrap())
+            .collect::<Vec<_>>();
+
+        let mut lexer = Lexer::<StrContent>::new(text);
+
+        while let Some(Ok(token)) = lexer.next() {
+            dbg!(&token);
+            dbg!(lexer.slice());
+        }
+
+        // Actual contains the last quote
+
+        assert_eq!(expected.len() + 1, actual.len());
+        assert_eq!(expected, &actual[..expected.len()]);
+
+        assert!(matches!(
+            actual.last(),
+            Some(StrContent::SingleQuote | StrContent::DoubleQuote)
+        ));
+    }
+
+    #[test]
+    fn test_newline() {
+        assert_str(
+            "hello\\nworld'",
+            &[StrContent::Normal, StrContent::Escape, StrContent::Normal],
+        );
+    }
+
+    #[test]
+    fn test_escape() {
+        assert_str(r#"\''"#, &[StrContent::Escape]);
+    }
+
+    #[test]
+    fn test_escape_escape() {
+        assert_str(r#"\\'"#, &[StrContent::Escape]);
+    }
+}
diff --git a/crates/swc_ecma_raw_lexer/tests/raw_lexer.rs b/crates/swc_ecma_raw_lexer/tests/raw_lexer.rs
new file mode 100644
index 000000000000..99fc9133b3d3
--- /dev/null
+++ b/crates/swc_ecma_raw_lexer/tests/raw_lexer.rs
@@ -0,0 +1,61 @@
+use logos::Logos;
+use swc_ecma_raw_lexer::RawToken;
+
+fn assert_str(s: &str) {
+    println!("String input: `{s}`");
+
+    let mut tokens = RawToken::lexer(s);
+
+    assert_eq!(tokens.next(), Some(Ok(RawToken::Str)));
+    assert_eq!(tokens.next(), None);
+
+    println!("Done")
+}
+
+fn assert_strs(s: &str) {
+    println!("String input: `{s}`");
+
+    let mut tokens = RawToken::lexer(s);
+
+    while let Some(Ok(token)) = tokens.next() {
+        assert_eq!(token, RawToken::Str);
+        assert_eq!(tokens.next(), Some(Ok(RawToken::Semi)));
+    }
+
+    assert_eq!(tokens.next(), None);
+}
+
+#[test]
+fn test_str_1() {
+    assert_str(r#""hello""#);
+    assert_str(r#"'hello'"#);
+}
+
+#[test]
+fn test_str_escape_single_char() {
+    assert_str(r#""hello\nworld""#);
+    assert_str(r#"'hello\nworld'"#);
+}
+
+#[test]
+fn test_str_escape_hex() {
+    assert_str(r#""use\x20strict""#);
+}
+
+#[test]
+fn test_str_escape_zero_octal() {
+    assert_str(r#""use\0strict""#);
+}
+
+#[test]
+fn test_str_escape_unicode() {
+    assert_str(r#""use\u2028strict""#);
+}
+
+#[test]
+fn test_str_escape_escape() {
+    assert_str(r#"'\\\\'"#);
+    assert_str(r#""\\\\""#);
+
+    assert_strs(r#"'\\\\';"\\\\";"#);
+}