diff --git a/CHANGELOG.rst b/CHANGELOG.rst
index 9c5c848..03110b5 100644
--- a/CHANGELOG.rst
+++ b/CHANGELOG.rst
@@ -20,6 +20,36 @@ Please see the fragment files in the `changelog.d directory`_.
 
 ..  scriv-insert-here
 
+.. _changelog-2.1.0:
+
+2.1.0 - 2026-08-02
+==================
+
+Fixed
+-----
+
+*   Close tags more correctly, even if the end tag has trailing text.
+
+    For example, ``</tag bonus>`` now closes ``<tag>`` correctly.
+    The trailing content is not available to parsers.
+
+*   Fix quadratic CPU usage in ``SGMLParser.feed()``.
+
+    This can occur when a large document with an unfinished token
+    (like ``<a href="...``) is fed into the parser in very small increments.
+
+    The new implementation doesn't significantly change peak memory usage.
+
+Changed
+-------
+
+*   Improve the closing tag search behavior of ``SGMLParser.finish_endtag()``.
+
+    Previously, the method always searched the entire tag stack
+    to close the innermost tag, which had a higher search cost.
+    The tag stack is now searched in reverse order
+    and breaks on the first matching tag.
+
 .. _changelog-2.0.1:
 
 2.0.1 - 2026-07-30
diff --git a/pyproject.toml b/pyproject.toml
index b69b2cf..7584863 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -1,7 +1,7 @@
 [project]
 name = "feedparser-sgmllib"
 description = "sgmllib from Python 2.7. For feedparser use only."
-version = "2.0.1"
+version = "2.1.0"
 maintainers = [
     { name = "Kurt McKee", email = "contactme@kurtmckee.org" },
 ]
diff --git a/src/feedparser_sgmllib/__init__.py b/src/feedparser_sgmllib/__init__.py
index dffdb10..96c0d05 100644
--- a/src/feedparser_sgmllib/__init__.py
+++ b/src/feedparser_sgmllib/__init__.py
@@ -13,6 +13,8 @@
 import re
 import typing as t
 
+from ._compat import StringIO
+
 __all__ = ["SGMLParser", "SGMLParseError"]
 
 # Regular expressions used for parsing
@@ -65,18 +67,59 @@ class SGMLParser(_markupbase.ParserBase):
     def __init__(self, verbose: bool = False) -> None:
         """Initialize and reset this instance."""
         self.verbose = verbose
+
+        # These variables help guard against quadratic CPU usage behavior
+        # without significantly increasing memory usage.
+        #
+        # Previously, each call to `.feed()` resulted in string-concatenation
+        # and a regular expression matching from the start of the raw data
+        # even though it was known that the existing raw data wouldn't match.
+        # For large unclosed tokens (like `<a href="...`) fed in small chunks,
+        # this became quadratically expensive.
+        #
+        # This quadratic CPU behavior is addressed by:
+        #
+        # * Gating failing calls to `.goahead()` behind an exponential backoff
+        # * Avoiding string concatenation until it's needed
+        #
+        # Memory usage is guarded by using an object with a resizeable buffer;
+        # a simple list of strings can increase memory usage significantly.
+        #
+        self._rawdata = ""
+        self._pending = StringIO()
+        self._retry_at = 0
+
         self.reset()
 
     def reset(self) -> None:
         """Reset this instance. Loses all unprocessed data."""
         self.__starttag_text: str | None = None
-        self.rawdata = ""
+        self._rawdata = ""
+        self._pending = StringIO()
+        self._retry_at = 0
         self.stack: list[str] = []
         self.lasttag = "???"
         self.nomoretags = 0
         self.literal = 0
         super().reset()
 
+    @property
+    def rawdata(self) -> str:
+        self._flush_pending()
+        return self._rawdata
+
+    @rawdata.setter
+    def rawdata(self, value: str) -> None:
+        self._rawdata = value
+        self._pending = StringIO()
+
+    def _flush_pending(self) -> None:
+        """Merge any chunks queued by `feed()` into `self._rawdata`."""
+
+        if self._pending.tell():
+            self._rawdata += self._pending.getvalue()
+            self._pending = StringIO()
+
     def setnomoretags(self) -> None:
         """Enter literal mode (CDATA) till EOF.
 
@@ -99,11 +142,19 @@ def feed(self, data: str) -> None:
         all the processing is done by goahead().)
         """
 
-        self.rawdata = self.rawdata + data
+        self._pending.write(data)
+        if len(self._rawdata) + self._pending.tell() < self._retry_at:
+            # The last attempt to resolve the pending token failed.
+            # Skip re-scanning until enough new data has arrived
+            # to make another attempt worthwhile.
+            return
+        self._flush_pending()
         self.goahead(False)
 
     def close(self) -> None:
         """Handle the remaining data."""
+
+        self._flush_pending()
         self.goahead(True)
 
     def error(self, message: str) -> t.NoReturn:
@@ -113,6 +164,7 @@ def error(self, message: str) -> t.NoReturn:
     # and data to be processed by a subsequent call.  If 'end' is
     # true, force handling all data as if followed by EOF marker.
     def goahead(self, end: bool) -> None:
+        # Accessing `self.rawdata` flushes pending data.
         rawdata = self.rawdata
         i = 0
         n = len(rawdata)
@@ -225,6 +277,15 @@ def goahead(self, end: bool) -> None:
             self.handle_data(rawdata[i:n])
             i = n
         self.rawdata = rawdata[i:]
+        if i == 0 and n > 0:
+            # No progress was made this call.
+            # Use exponential back off to set how much new data must arrive
+            # before the next scan retry.
+            # This ensures a persistently-incomplete token costs O(n) overall
+            # instead of O(n**2).
+            self._retry_at = n * 2
+        else:
+            self._retry_at = 0
         # XXX if end: check for empty stack
 
     # Extensions for the DOCTYPE scanner:
@@ -361,6 +422,8 @@ def finish_starttag(
 
     # Internal -- finish processing of end tag
     def finish_endtag(self, tag: str) -> None:
+        if (match := tagfind.match(tag)) is not None:
+            tag = match.group(0)
         if not tag:
             found = len(self.stack) - 1
             if found < 0:
@@ -369,23 +432,21 @@ def finish_endtag(self, tag: str) -> None:
         else:
             if tag not in self.stack:
                 try:
-                    method = getattr(self, "end_" + tag)
+                    getattr(self, "end_" + tag)
                 except AttributeError:
                     self.unknown_endtag(tag)
                 else:
                     self.report_unbalanced(tag)
                 return
             found = len(self.stack)
-            for i in range(found):
-                if self.stack[i] == tag:
-                    found = i
+            for i, stack_tag in enumerate(reversed(self.stack)):
+                if stack_tag == tag:
+                    found = len(self.stack) - 1 - i
+                    break
         while len(self.stack) > found:
             tag = self.stack[-1]
-            try:
-                method = getattr(self, "end_" + tag)
-            except AttributeError:
-                method = None
-            if method:
+            method: t.Callable[[], t.Any] | None = getattr(self, "end_" + tag, None)
+            if method is not None:
                 self.handle_endtag(tag, method)
             else:
                 self.unknown_endtag(tag)
diff --git a/src/feedparser_sgmllib/_compat.py b/src/feedparser_sgmllib/_compat.py
new file mode 100644
index 0000000..2f67667
--- /dev/null
+++ b/src/feedparser_sgmllib/_compat.py
@@ -0,0 +1,38 @@
+# Manage compatibility across supported Python versions.
+
+import sys
+
+__all__ = [
+    "StringIO",
+]
+
+
+if sys.version_info >= (3, 12):
+    from io import StringIO
+else:
+    # In Python >=3.12, `io.StringIO` has good memory allocation performance,
+    # which makes it a good candidate for collecting unparsed input data
+    # (see the comment in `SGMLParser.__init__()` about CPU and memory usage).
+    #
+    # However, the performance of `io.StringIO` is poor in Python 3.11 and below.
+    # For these lower Python versions, bytearray exhibits good performance
+    # but requires manual tracking of the length of the decoded string
+    # as well as calls to `.encode()` and `.decode()`.
+    #
+    # Therefore, the `io.StringIO` interface is mimicked here
+    # and backed by a bytearray implementation.
+    class StringIO:
+        def __init__(self) -> None:
+            self._buffer = bytearray()
+            self._length = 0
+
+        def write(self, text: str) -> int:
+            self._buffer.extend(text.encode())
+            self._length += len(text)
+            return len(text)
+
+        def getvalue(self) -> str:
+            return self._buffer.decode()
+
+        def tell(self) -> int:
+            return self._length
diff --git a/tests/conftest.py b/tests/conftest.py
index d4dd00d..e9aa9db 100644
--- a/tests/conftest.py
+++ b/tests/conftest.py
@@ -128,3 +128,29 @@ def handle_charref(self, name):
     def handle_entityref(self, name):
         self.events.append(("entityref", name))
         sgmllib.SGMLParser.handle_entityref(self, name)
+
+
+class NestedTagCollector(sgmllib.SGMLParser):
+    def __init__(self) -> None:
+        super().__init__()
+        self.events = []
+
+    def start_a(self, attrs):
+        self.events.append(("start_a", attrs))
+
+    def end_a(self):
+        self.events.append(("end_a",))
+
+    def start_b(self, attrs):
+        self.events.append(("start_b", attrs))
+
+    def end_b(self):
+        self.events.append(("end_b",))
+
+    def unknown_endtag(self, tag):
+        self.events.append(("unknown_endtag", tag))
+
+
+@pytest.fixture
+def nested_tag_collector() -> NestedTagCollector:
+    return NestedTagCollector()
diff --git a/tests/test_sgmllib.py b/tests/test_sgmllib.py
index 0387e8a..348903a 100644
--- a/tests/test_sgmllib.py
+++ b/tests/test_sgmllib.py
@@ -1,5 +1,7 @@
 import io
 import pathlib
+import time
+import tracemalloc
 
 import pytest
 
@@ -455,6 +457,190 @@ def test_attrfind_trailing_dollar_sign():
     assert sgmllib.attrfind.search(text).groups() == ("i", '="true"', '"true"')
 
 
+def test_endtag_closes_innermost_matching_tag(nested_tag_collector):
+    """
+    Regression test: Confirm closing tags close innermost tags.
+
+    For example:
+
+        <a id="1"> <b> <a id="2"></a>
+
+    The </a> must close id=2 only, leaving <b> open.
+    """
+
+    nested_tag_collector.feed('<a id="1"><b></c><a id="2"></a>')
+
+    assert nested_tag_collector.events == [
+        ("start_a", [("id", "1")]),
+        ("start_b", []),
+        ("unknown_endtag", "c"),
+        ("start_a", [("id", "2")]),
+        ("end_a",),
+    ]
+    assert nested_tag_collector.stack == ["a", "b"]
+
+    # The innermost <a> (id=2) should be closed, and <b> should still be open.
+    # Therefore, `end_b` should be called, not `unknown_endtag`.
+    nested_tag_collector.feed("</b>")
+    assert nested_tag_collector.events[-1] == ("end_b",)
+    assert nested_tag_collector.stack == ["a"]
+
+
+@pytest.mark.parametrize(
+    "trailing_text",
+    (
+        " bonus",
+        "/",
+        "=x",
+        ";",
+        ",",
+    ),
+)
+def test_endtag_with_trailing_content_still_closes_tag(
+    cdata_event_collector, trailing_text
+):
+    """Verify that a closing tag with trailing content still closes the tag."""
+
+    cdata_event_collector.check_events(
+        f"<cdata>content</cdata{trailing_text}>after",
+        [
+            ("starttag", "cdata", []),
+            ("data", "content"),
+            ("endtag", "cdata"),
+            ("data", "after"),
+        ],
+    )
+    assert cdata_event_collector.stack == []
+
+
+def test_endtag_with_no_valid_tag_name_does_not_close_open_tag(nested_tag_collector):
+    """Verify invalid tag names do not close any open tags."""
+
+    nested_tag_collector.feed("<a>content</123>after")
+
+    assert nested_tag_collector.events == [
+        ("start_a", []),
+        ("unknown_endtag", "123"),
+    ]
+    assert nested_tag_collector.stack == ["a"]
+
+
+@pytest.mark.parametrize(
+    "prefix",
+    (
+        pytest.param('<a href="', id="starttag-unterminated-attribute"),
+        pytest.param("</", id="endtag-missing-close-bracket"),
+        pytest.param("<?", id="processing-instruction-missing-close"),
+        pytest.param("<!--", id="comment-missing-close"),
+        pytest.param("<!DOCTYPE ", id="declaration-missing-close"),
+        pytest.param("<![CDATA[", id="marked-section-missing-close"),
+    ),
+)
+def test_feed_unresolved_token_scales_cpu_time_linearly(prefix):
+    """
+    Verify `.feed()` doesn't exhibit quadratic CPU time usage.
+
+    This is verified by creating a very large, incomplete token
+    (like an unclosed start tag) and feeding it to the parser
+    one byte at a time. The amount of CPU time required for this
+    suggests whether the parser has redeveloped quadratic behavior.
+
+    The first and last quarters of the data feed times are measured
+    because linear behavior should keep their ratio close to 1.
+    Having two quarters' worth of data between the measured quarters
+    helps make quadratic behavior much more noticeable.
+    """
+
+    n = 60_000
+    length = n - len(prefix)
+    payload = prefix + ("x" * length)
+    parser = sgmllib.SGMLParser()
+
+    quarter = n // 4
+    checkpoints = []
+    start = time.process_time()
+    for i, character in enumerate(payload, start=1):
+        parser.feed(character)
+        # At the end of each content quarter,
+        # capture the processing time and restart the timer.
+        if i % quarter == 0:
+            checkpoints.append(time.process_time() - start)
+            start = time.process_time()
+
+    assert len(checkpoints) == 4
+    first_quarter, last_quarter = checkpoints[0], checkpoints[-1]
+
+    max_allowed_growth = 2.5
+    # The numbers are scaled up to try to avoid close-to-zero float math problems.
+    budget = (first_quarter * 10_000) * max_allowed_growth
+    assert last_quarter * 10_000 <= budget, (
+        f"The cost of the last quarter of feed() calls ({last_quarter:.3f}s) "
+        f"exceeded {max_allowed_growth}x the cost of the first quarter "
+        f"({first_quarter:.3f}s) for prefix {prefix!r}. "
+        f"This suggests quadratic behavior."
+    )
+
+
+def test_feed_unresolved_token_peak_memory_scales_nicely():
+    """
+    Verify `.feed()` doesn't show a big peak memory usage constant multiplier.
+
+    This is verified by creating a very large, incomplete token
+    (like an unclosed start tag) and feeding it to the parser
+    one character at a time.
+
+    In the past, each character was concatenated each time `.feed()` is called.
+    For a large input, peak memory usage was always ~2x the current input size:
+    concatenation copied the existing string in memory to add a single character.
+
+    The initial fix for quadratic CPU usage replaced string concatenation
+    in favor of buffering incoming strings in a list.
+    However, this caused a jump in the peak memory usage constant multiplier:
+    now, in addition to the strings themselves, lots of references to the strings
+    had to be created and stored in the list buffer.
+
+    The solution was to replace the list of strings with something
+    which has a resizeable internal buffer and can store the incoming data
+    without the added cost of maintaining references or concatenating content.
+    """
+
+    # 200,000 should be big enough to dominate memory usage while the test runs
+    # so that peak memory usage is primarily influenced by the input payload
+    # and its final string-concatenation.
+    n = 200_000
+
+    prefix = '<a href="'
+    length = n - len(prefix)
+    payload = prefix + ("x" * length)
+    parser = sgmllib.SGMLParser()
+
+    tracemalloc.start()
+    try:
+        for ch in payload:
+            parser.feed(ch)
+        parser.close()
+        _, peak = tracemalloc.get_traced_memory()
+    finally:
+        tracemalloc.stop()
+
+    # The `max_allowed_ratio` reflects how large peak memory usage can be
+    # when compared to the size of the input payload.
+    # As long as the input payload dominates memory usage while the test runs,
+    # the string concatenation of the `SGMLParser._rawdata`
+    # with the buffered, unparsed data in `._pending` should double peak usage.
+    #
+    # The max allowed ratio is set to 3.0 to allow for other memory use,
+    # but is still lower than what was measured when a list of strings was used
+    # to accumulate unparsed input data.
+    max_allowed_ratio = 3.0
+    budget = n * max_allowed_ratio
+    assert peak <= budget, (
+        f"Peak traced memory ({peak:,} bytes) exceeded "
+        f"{max_allowed_ratio}x the input size ({len(payload):,} bytes) "
+        "while feeding an unresolved token byte-at-a-time."
+    )
+
+
 # XXX These tests have been disabled by prefixing their names with
 # an underscore.  The first two exercise outstanding bugs in the
 # sgmllib module, and the third exhibits questionable behavior