diff --git a/Sources/HTMLEntities/namedChars.swift b/Sources/HTMLEntities/namedChars.swift
index 5f0d314..00878fe 100644
--- a/Sources/HTMLEntities/namedChars.swift
+++ b/Sources/HTMLEntities/namedChars.swift
@@ -2231,3 +2231,17 @@ public let namedChars: [String: (Unicode.Scalar, Unicode.Scalar)] = [
     "yen": ("\u{A5}", "\0"),
     "yuml": ("\u{FF}", "\0"),
 ]
+
+// FIXME: This process should be done at compile-time, not runtime.
+public let processedNamedChars: [String: (Unicode.Scalar, Unicode.Scalar)] = {
+    var namedChars = namedChars
+    for key in namedChars.keys {
+        for i in 1..<key.count {
+            let k = String(key.prefix(i))
+            if !namedChars.keys.contains(k) {
+                namedChars[k] = ("\0", "\0")
+            }
+        }
+    }
+    return namedChars
+}()
diff --git a/Sources/Tokenizer/CharRefTokenizer.swift b/Sources/Tokenizer/CharRefTokenizer.swift
index 435809f..736d65a 100644
--- a/Sources/Tokenizer/CharRefTokenizer.swift
+++ b/Sources/Tokenizer/CharRefTokenizer.swift
@@ -4,6 +4,7 @@ private import HTMLEntities
 private enum CharRefState {
     case initial
     case named
+    case namedEnd(endIndex: String.Index, replaceChars: (Unicode.Scalar, Unicode.Scalar))
     case ambiguousAmpersand
     case numeric
     case hexadecimalStart(uppercase: Bool)
@@ -23,12 +24,19 @@ struct CharRefTokenizer {
     private var state: CharRefState = .initial
     private var num: Int = 0
     private var numTooBig: Bool = false
+    private var nameBuffer: String = ""
+    private var lastMatch: (endIndex: String.Index, replaceChars: (Unicode.Scalar, Unicode.Scalar))?
+    private let isInAttr: Bool
+
+    init(inAttr isInAttr: Bool) {
+        self.isInAttr = isInAttr
+    }
 
     mutating func tokenize(tokenizer: inout Tokenizer<some TokenSink>, input: inout Deque<Character>) -> [Unicode.Scalar]? {
         repeat {
             switch self.step(tokenizer: &tokenizer, input: &input) {
             case .done(let scalars): return scalars
-            case .doneNone: return nil
+            case .doneNone: return ["&"]
             case .progress: break
             }
         } while true
@@ -45,28 +53,66 @@ struct CharRefTokenizer {
                 tokenizer.discardChar(&input)
                 self.state = .numeric
                 return .progress
-            case _: return .done(["&"])
+            case _: return .doneNone
             }
         case .named:
-            // TODO: If there is a match
-            guard false else {
-                // TODO: Flush code points consumed as a character reference
-                tokenizer.processCharRef("&")
-                self.state = .ambiguousAmpersand
+            guard let c = tokenizer.peek(input) else {
+                guard let (endIndex, chars) = lastMatch else {
+                    input.prepend(contentsOf: self.nameBuffer)
+                    return .doneNone
+                }
+                self.state = .namedEnd(endIndex: endIndex, replaceChars: chars)
                 return .progress
             }
+            tokenizer.discardChar(&input)
+            self.nameBuffer.append(c)
+            switch processedNamedChars[self.nameBuffer] {
+            case ("\0", _)?: break
+            case let chars?: lastMatch = (self.nameBuffer.endIndex, chars)
+            case nil:
+                if let (endIndex, chars) = lastMatch {
+                    self.state = .namedEnd(endIndex: endIndex, replaceChars: chars)
+                } else {
+                    self.state = .ambiguousAmpersand
+                }
+            }
+            return .progress
+        case .namedEnd(let endIndex, let replaceChars):
+            // swift-format-ignore: NeverForceUnwrap
+            let lastChar = self.nameBuffer[..<endIndex].last!.firstScalar
+            let nextChar: Unicode.Scalar? =
+                if self.nameBuffer.endIndex != endIndex {
+                    self.nameBuffer[endIndex].firstScalar
+                } else {
+                    nil
+                }
+            switch (isInAttr, lastChar, nextChar) {
+            case (_, ";", _): break
+            case (true, _, "="?), (true, _, ("0"..."9")?), (true, _, ("A"..."Z")?), (true, _, ("a"..."z")?):
+                input.prepend(contentsOf: self.nameBuffer)
+                return .doneNone
+            case _: tokenizer.emitError(.missingSemicolon)
+            }
+            input.prepend(contentsOf: self.nameBuffer[endIndex...])
+            return switch replaceChars {
+            case (let c1, "\0"): .done([c1])
+            case (let c1, let c2): .done([c1, c2])
+            }
         case .ambiguousAmpersand:
-            guard let c = tokenizer.peek(input) else { return .doneNone }
+            guard let c = tokenizer.peek(input) else {
+                input.prepend(contentsOf: self.nameBuffer)
+                return .doneNone
+            }
             switch c.firstScalar {
             case "0"..."9", "A"..."Z", "a"..."z":
                 tokenizer.discardChar(&input)
-                tokenizer.processCharRef(c)
+                self.nameBuffer.append(c)
                 return .progress
-            case ";":
-                tokenizer.emitError(.unknownNamedCharRef)
-                return .doneNone
-            case _: return .doneNone
+            case ";": tokenizer.emitError(.unknownNamedCharRef)
+            case _: break
             }
+            input.prepend(contentsOf: self.nameBuffer)
+            return .doneNone
         case .numeric:
             switch tokenizer.peek(input) {
             case "X":
@@ -88,7 +134,8 @@ struct CharRefTokenizer {
                 return .progress
             case _:
                 tokenizer.emitError(.absenceDigits)
-                return .done(["&", "#", uppercase ? "X" : "x"])
+                input.prepend(contentsOf: uppercase ? "#X" : "#x")
+                return .doneNone
             }
         case .decimalStart:
             switch tokenizer.peek(input)?.firstScalar {
@@ -97,7 +144,8 @@ struct CharRefTokenizer {
                 return .progress
             case _:
                 tokenizer.emitError(.absenceDigits)
-                return .done(["&", "#"])
+                input.prepend("#")
+                return .doneNone
             }
         case .hexadecimal:
             if let firstScalar = tokenizer.peek(input)?.firstScalar {
diff --git a/Sources/Tokenizer/Tokenizer.swift b/Sources/Tokenizer/Tokenizer.swift
index 2c8386f..04941ce 100644
--- a/Sources/Tokenizer/Tokenizer.swift
+++ b/Sources/Tokenizer/Tokenizer.swift
@@ -40,7 +40,7 @@ public import Collections
 @freestanding(codeItem) private macro goEmitDOCTYPEAndEOF() = #externalMacro(module: "TokenizerMacros", type: "GoMacro")
 @freestanding(codeItem) private macro goEmitForceQuirksDOCTYPEAndEOF() = #externalMacro(module: "TokenizerMacros", type: "GoMacro")
 @freestanding(codeItem) private macro goEmitNewForceQuirksDOCTYPEAndEOF() = #externalMacro(module: "TokenizerMacros", type: "GoMacro")
-@freestanding(codeItem) private macro goConsumeCharRef() = #externalMacro(module: "TokenizerMacros", type: "GoMacro")
+@freestanding(codeItem) private macro goConsumeCharRef(inAttr: Bool) = #externalMacro(module: "TokenizerMacros", type: "GoMacro")
 
 public struct Tokenizer<Sink: TokenSink>: ~Copyable {
     public var sink: Sink
@@ -94,7 +94,7 @@ public struct Tokenizer<Sink: TokenSink>: ~Copyable {
         switch self.state {
         case .data: repeat {
             switch self.getChar(from: &input) {
-            case "&": #goConsumeCharRef
+            case "&": #goConsumeCharRef(inAttr: false)
             case "<": #go(to: .tagOpen)
             case "\0": #go(error: .unexpectedNull, emit: "\0")
             case nil: #go(emit: .eof)
@@ -103,7 +103,7 @@ public struct Tokenizer<Sink: TokenSink>: ~Copyable {
         } while true
         case .rcdata: repeat {
             switch self.getChar(from: &input) {
-            case "&": #goConsumeCharRef
+            case "&": #goConsumeCharRef(inAttr: false)
             case "<": #go(to: .rcdataLessThanSign)
             case "\0": #go(error: .unexpectedNull, emit: "\u{FFFD}")
             case nil: #go(emit: .eof)
@@ -508,7 +508,7 @@ public struct Tokenizer<Sink: TokenSink>: ~Copyable {
         case .attributeValueDoubleQuoted: repeat {
             switch self.getChar(from: &input) {
             case "\"": #go(to: .afterAttributeValueQuoted)
-            case "&": #goConsumeCharRef
+            case "&": #goConsumeCharRef(inAttr: true)
             case "\0": #go(error: .unexpectedNull, appendAttrValue: "\u{FFFD}")
             case nil: #go(error: .eofInTag, emit: .eof)
             case let c?: #go(appendAttrValue: c)
@@ -517,7 +517,7 @@ public struct Tokenizer<Sink: TokenSink>: ~Copyable {
         case .attributeValueSingleQuoted: repeat {
             switch self.getChar(from: &input) {
             case "'": #go(to: .afterAttributeValueQuoted)
-            case "&": #goConsumeCharRef
+            case "&": #goConsumeCharRef(inAttr: true)
             case "\0": #go(error: .unexpectedNull, appendAttrValue: "\u{FFFD}")
             case nil: #go(error: .eofInTag, emit: .eof)
             case let c?: #go(appendAttrValue: c)
@@ -526,7 +526,7 @@ public struct Tokenizer<Sink: TokenSink>: ~Copyable {
         case .attributeValueUnquoted: repeat {
             switch self.getChar(from: &input) {
             case "\t", "\n", "\u{0C}", " ": #go(to: .beforeAttributeName)
-            case "&": #goConsumeCharRef
+            case "&": #goConsumeCharRef(inAttr: true)
             case ">": #go(emitTag: .data)
             case "\0": #go(error: .unexpectedNull, appendAttrValue: "\u{FFFD}")
             case nil: #go(error: .eofInTag, emit: .eof)
@@ -1138,8 +1138,8 @@ public struct Tokenizer<Sink: TokenSink>: ~Copyable {
     }
 
     @inline(__always)
-    private mutating func consumeCharRef() {
-        self.charRefTokenizer = .init()
+    private mutating func consumeCharRef(inAttr isInAttr: Bool) {
+        self.charRefTokenizer = .init(inAttr: isInAttr)
     }
 }
 
diff --git a/Sources/TokenizerMacros/Macros.swift b/Sources/TokenizerMacros/Macros.swift
index a3d1639..554b8ea 100644
--- a/Sources/TokenizerMacros/Macros.swift
+++ b/Sources/TokenizerMacros/Macros.swift
@@ -162,7 +162,7 @@ extension GoMacro: CodeItemMacro {
         case "goEmitNewForceQuirksDOCTYPEAndEOF":
             return ["self.createDOCTYPE()", "self.forceQuirks()", "self.emitDOCTYPE()", "self.emitEOF()", "return .suspend"]
         case "goConsumeCharRef":
-            return ["self.consumeCharRef()", "return .continue"]
+            return ["self.consumeCharRef(\(node.arguments))", "return .continue"]
         case let name:
             preconditionFailure("not supported: \(name)")
         }
diff --git a/Tests/TokenizerTests/HTML5LibTests.swift b/Tests/TokenizerTests/HTML5LibTests.swift
index 3ebde1f..15ce1c3 100644
--- a/Tests/TokenizerTests/HTML5LibTests.swift
+++ b/Tests/TokenizerTests/HTML5LibTests.swift
@@ -6,13 +6,27 @@ private import Tokenizer
 private struct TestSink {
     var tokens = [Token]()
     var errors = [ParseError]()
+    var pendingChars = ""
+
+    consuming func finalize() -> ([Token], [ParseError]) {
+        self.processChars()
+        return (self.tokens, self.errors)
+    }
+
+    private mutating func processChars() {
+        self.tokens.append(contentsOf: self.pendingChars.map(Token.char))
+        self.pendingChars.removeAll()
+    }
 }
 
 extension TestSink: TokenSink {
     mutating func process(_ token: consuming Token) {
         switch token {
         case .error(let error): self.errors.append(error)
-        case let token: self.tokens.append(token)
+        case .char(let c): self.pendingChars.append(c)
+        case let token:
+            self.processChars()
+            self.tokens.append(token)
         }
     }
 }
@@ -25,7 +39,7 @@ private let testCases = try! [
     Bundle.module.url(forResource: "test4", withExtension: "test")!,
     Bundle.module.url(forResource: "unicodeChars", withExtension: "test")!,
     Bundle.module.url(forResource: "entities", withExtension: "test")!,
-    // Bundle.module.url(forResource: "namedEntities", withExtension: "test")!,
+    Bundle.module.url(forResource: "namedEntities", withExtension: "test")!,
     Bundle.module.url(forResource: "numericEntities", withExtension: "test")!,
     Bundle.module.url(forResource: "pendingSpecChanges", withExtension: "test")!,
     // Bundle.module.url(forResource: "contentModelFlags", withExtension: "test")!,
@@ -36,31 +50,12 @@ private let testCases = try! [
 
 @Test("html5lib-tests", arguments: testCases)
 func html5libTests(_ testCase: TestCase) throws {
-    // TODO: Do not ignore any test cases
-    switch testCase.title {
-    // test1.test
-    case "Entity with trailing semicolon (1)": return
-    case "Entity with trailing semicolon (2)": return
-    case "Entity without trailing semicolon (1)": return
-    case "Entity without trailing semicolon (2)": return
-    case "Entity in attribute without semicolon": return
-    // test2.test
-    case "Entity + newline": return
-    // entities.test
-    case "Undefined named entity in a double-quoted attribute value ending in semicolon and whose name starts with a known entity name.": return
-    case "Undefined named entity in a single-quoted attribute value ending in semicolon and whose name starts with a known entity name.": return
-    case "Undefined named entity in an unquoted attribute value ending in semicolon and whose name starts with a known entity name.": return
-    case "Semicolonless named entity 'not' followed by 'i;' in body": return
-    case _: break
-    }
-
     var tokenizer = Tokenizer(sink: TestSink())
     tokenizer.state = testCase.initialState
     var input = Deque(testCase.input)
     tokenizer.tokenize(&input)
 
-    let tokens = tokenizer.sink.tokens
-    let errors = tokenizer.sink.errors
+    let (tokens, errors) = tokenizer.sink.finalize()
     #expect(tokens == testCase.tokens)
     #expect(errors.count == testCase.errors.count)  // TODO: Make it stricter
 }